public Expression IndexOfMethod(IndexOfMethod method, LiteralExpression[] arguments) { int result; if (LiteralUtil.IsAnyNull(arguments)) { result = -1; } else { result = LiteralUtil.CoerceString(arguments[0]).IndexOf( LiteralUtil.CoerceString(arguments[1]), StringComparison.InvariantCultureIgnoreCase ); } if (result == -1) { return(new LiteralExpression(null, LiteralType.Null)); } else { return(new LiteralExpression(result + 1, LiteralType.Int)); } }
private ICriterion CreateLikeCriterion(Expression projectionExpression, Expression literalExpression, MatchMode matchMode) { var projection = ProjectionVisitor.CreateProjection(projectionExpression); var value = LiteralUtil.CoerceString((LiteralExpression)literalExpression); return(_context.CaseSensitiveLike ? Restrictions.Like(projection, value, matchMode) : Restrictions.InsensitiveLike(projection, value, matchMode)); }
public Expression CastMethod(CastMethod method, LiteralExpression[] arguments) { Debug.Assert(arguments[1].LiteralType == LiteralType.String); if (arguments[0].LiteralType == LiteralType.Null) { return(arguments[0]); } var type = LiteralUtil.GetCompatibleType((string)arguments[1].Value); try { return(new LiteralExpression(Convert.ChangeType(arguments[0].Value, type, CultureInfo.InvariantCulture))); } catch (Exception ex) { throw new ODataException( String.Format( ErrorMessages.Method_CannotCast, arguments[1].Value ), ex ); } }
public Expression ConcatMethod(ConcatMethod method, LiteralExpression[] arguments) { if (arguments.Length == 1) { return(arguments[0]); } else if (arguments[0].LiteralType == LiteralType.Null) { if (arguments[1].LiteralType == LiteralType.Null) { return(new LiteralExpression(null, LiteralType.Null)); } else { return(arguments[1]); } } else if (arguments[1].LiteralType == LiteralType.Null) { return(arguments[0]); } else { string result = LiteralUtil.CoerceString(arguments[0]) + LiteralUtil.CoerceString(arguments[1]); return(new LiteralExpression(result, LiteralType.String)); } }
private Expression ResolveArithmeticLiterals(ArithmeticExpression expression, LiteralExpression leftLiteral, LiteralExpression rightLiteral) { object left = leftLiteral.Value; object right = rightLiteral.Value; object result; var type = LiteralUtil.CoerceLiteralValues(ref left, leftLiteral.LiteralType, ref right, rightLiteral.LiteralType); switch (expression.Operator) { case Operator.Add: result = ResolveAdd(left, right, type); break; case Operator.Div: result = ResolveDiv(left, right, type); break; case Operator.Mod: result = ResolveMod(left, right, type); break; case Operator.Mul: result = ResolveMul(left, right, type); break; case Operator.Sub: result = ResolveSub(left, right, type); break; default: throw new NotSupportedException(); } if (result == null) { throw new ODataException(String.Format( ErrorMessages.Expression_IncompatibleTypes, expression.Operator, type )); } return(new LiteralExpression(result, type)); }
public Expression SubStringOfMethod(SubStringOfMethod method, LiteralExpression[] arguments) { if (arguments.Length == 1) { return(arguments[0]); } else { bool result; if (LiteralUtil.IsAnyNull(arguments)) { result = false; } else { result = LiteralUtil.CoerceString(arguments[1]).IndexOf( LiteralUtil.CoerceString(arguments[0]), StringComparison.InvariantCultureIgnoreCase ) != -1; } return(new LiteralExpression(result, LiteralType.Boolean)); } }
public Expression IsOfMethod(IsOfMethod method, LiteralExpression[] arguments) { Debug.Assert(arguments[1].LiteralType == LiteralType.String); var type = LiteralUtil.GetCompatibleType((string)arguments[1].Value); return(new LiteralExpression(type.IsInstanceOfType(arguments[0].Value), LiteralType.Boolean)); }
public LiteralToken(object value, LiteralType literalType) : base(TokenType.Literal) { Value = value; LiteralType = literalType; Debug.Assert(literalType == LiteralUtil.GetLiteralType(value)); }
private bool ResolveEquals(object left, object right, LiteralType type) { if (type == LiteralType.Binary) { return(LiteralUtil.ByteArrayEquals((byte[])left, (byte[])right)); } else { return(Equals(left, right)); } }
public Expression LengthMethod(LengthMethod method, LiteralExpression[] arguments) { if (LiteralUtil.IsAnyNull(arguments)) { return(new LiteralExpression(null, LiteralType.Null)); } else { int result = LiteralUtil.CoerceString(arguments[0]).Length; return(new LiteralExpression(result, LiteralType.Int)); } }
public Expression TrimMethod(TrimMethod method, LiteralExpression[] arguments) { if (LiteralUtil.IsAnyNull(arguments)) { return(new LiteralExpression(null, LiteralType.Null)); } else { string result = LiteralUtil.CoerceString(arguments[0]).Trim(); return(new LiteralExpression(result, LiteralType.String)); } }
public Expression ReplaceMethod(ReplaceMethod method, LiteralExpression[] arguments) { if (LiteralUtil.IsAnyNull(arguments)) { return(new LiteralExpression(null, LiteralType.Null)); } else { string result = LiteralUtil.CoerceString(arguments[0]).Replace( LiteralUtil.CoerceString(arguments[1]), LiteralUtil.CoerceString(arguments[2]) ); return(new LiteralExpression(result, LiteralType.String)); } }
public Expression EndsWithMethod(EndsWithMethod method, LiteralExpression[] arguments) { bool result; if (LiteralUtil.IsAnyNull(arguments)) { result = false; } else { result = LiteralUtil.CoerceString(arguments[0]).EndsWith( LiteralUtil.CoerceString(arguments[1]), StringComparison.InvariantCultureIgnoreCase ); } return(new LiteralExpression(result, LiteralType.Boolean)); }
public override IProjection CastMethod(CastMethod method, Expression[] arguments) { var projection = ProjectionVisitor.CreateProjection(arguments[0]); switch (LiteralUtil.CoerceString((LiteralExpression)arguments[1])) { case "Edm.Byte": case "Edm.SByte": case "Edm.Int16": case "Edm.Int32": return(new SqlFunctionProjection("round", NHibernateUtil.Int32, projection)); case "Edm.Int64": return(new SqlFunctionProjection("round", NHibernateUtil.Int64, projection)); default: return(projection); } }
public Expression SubStringMethod(SubStringMethod method, LiteralExpression[] arguments) { if (arguments[0].LiteralType == LiteralType.Null) { return(arguments[0]); } else { int startIndex; int length; string result; if (!LiteralUtil.TryCoerceInt(arguments[1], out startIndex)) { throw new ODataException(String.Format( ErrorMessages.Method_InvalidArgumentType, method.MethodType, 2, "Edm.Int32" )); } if (arguments.Length == 3) { if (!LiteralUtil.TryCoerceInt(arguments[2], out length)) { throw new ODataException(String.Format( ErrorMessages.Method_InvalidArgumentType, method.MethodType, 3, "Edm.Int32" )); } result = LiteralUtil.CoerceString(arguments[0]).Substring(startIndex - 1, length); } else { result = LiteralUtil.CoerceString(arguments[0]).Substring(startIndex - 1); } return(new LiteralExpression(result, LiteralType.String)); } }
private Expression ResolveComparisonLiterals(ComparisonExpression expression, LiteralExpression leftLiteral, LiteralExpression rightLiteral) { object left = leftLiteral.Value; object right = rightLiteral.Value; bool result; var type = LiteralUtil.CoerceLiteralValues(ref left, leftLiteral.LiteralType, ref right, rightLiteral.LiteralType); switch (expression.Operator) { case Operator.Eq: result = ResolveEquals(left, right, type); break; case Operator.Ne: result = !ResolveEquals(left, right, type); break; case Operator.Gt: result = ResolveCompare(left, right, type) > 0; break; case Operator.Ge: result = ResolveCompare(left, right, type) >= 0; break; case Operator.Lt: result = ResolveCompare(left, right, type) < 0; break; case Operator.Le: result = ResolveCompare(left, right, type) <= 0; break; default: throw new NotSupportedException(); } return(new LiteralExpression(result, LiteralType.Boolean)); }
private Expression NormalizeDatePart(DatePartMethod method, LiteralExpression[] arguments) { if (LiteralUtil.IsAnyNull(arguments)) { return(new LiteralExpression(null, LiteralType.Null)); } else if (arguments[0].LiteralType != LiteralType.DateTime) { throw new ODataException(String.Format( ErrorMessages.Method_InvalidArgumentType, method.MethodType, 1, "Edm.DateTime" )); } else { var argument = (DateTime)arguments[0].Value; int result; switch (method.MethodType) { case MethodType.Year: result = argument.Year; break; case MethodType.Month: result = argument.Month; break; case MethodType.Day: result = argument.Day; break; case MethodType.Hour: result = argument.Hour; break; case MethodType.Minute: result = argument.Minute; break; case MethodType.Second: result = argument.Second; break; default: throw new NotSupportedException(); } return(new LiteralExpression(result, LiteralType.Int)); } }
private static XElement AddProperty(string propertyName, IType propertyType, object value) { var propertyElement = new XElement( ODataService.NsDataServices + propertyName ); if (propertyType.ReturnedClass != typeof(string)) { propertyElement.Add(new XAttribute(ODataService.NsMetadata + "type", LiteralUtil.GetEdmType(propertyType.ReturnedClass))); } string serialized = LiteralUtil.SerializeValue(value); if (serialized == null) { propertyElement.Add(new XAttribute(ODataService.NsMetadata + "null", "true")); } else { propertyElement.Add(new XText(serialized)); } return(propertyElement); }
public override bool Equals(object obj) { if (ReferenceEquals(this, obj)) { return(true); } var other = obj as LiteralToken; if (other == null) { return(false); } var bytes = Value as byte[]; var otherBytes = other.Value as byte[]; if (bytes != null && otherBytes != null) { return(LiteralUtil.ByteArrayEquals(bytes, otherBytes)); } return(Equals(Value, other.Value)); }
private string CreateMetadataResponse() { var schemaElement = new XElement( NsEdm + "Schema", new XAttribute(XNamespace.Xmlns + "d", NsDataServices), new XAttribute(XNamespace.Xmlns + "m", NsMetadata), new XAttribute("xmlns", NsEdm), new XAttribute("Namespace", SchemaNamespace) ); var entityContainerElement = new XElement( NsEdm + "EntityContainer", new XAttribute("Name", ContainerName), new XAttribute(NsMetadata + "IsDefaultEntityContainer", "true") ); var associations = new Dictionary <string, XElement>(); foreach (var type in _sessionFactory.GetAllClassMetadata().Values) { var persister = GetPersister(type); string entityName = persister.EntityType.ReturnedClass.Name; var entityElement = new XElement( NsEdm + "EntityType", new XAttribute("Name", entityName), new XElement( NsEdm + "Key", new XElement( NsEdm + "PropertyRef", new XAttribute("Name", persister.IdentifierPropertyName) ) ) ); schemaElement.Add(entityElement); entityElement.Add(new XElement( NsEdm + "Property", new XAttribute("Name", persister.IdentifierPropertyName), new XAttribute("Type", LiteralUtil.GetEdmType(persister.IdentifierType.ReturnedClass)), new XAttribute("Nullable", "false") )); foreach (var property in persister.EntityMetamodel.Properties) { var collectionType = property.Type as CollectionType; var manyToOneType = property.Type as ManyToOneType; var propertyType = property.Type.ReturnedClass; if (collectionType != null || manyToOneType != null) { string fromRole; string toRole; string relationship; string multiplicity; if (collectionType != null) { propertyType = propertyType.GetGenericArguments()[0]; fromRole = entityName + "_" + property.Name; toRole = propertyType.Name + "_" + entityName; relationship = toRole + "_" + fromRole; multiplicity = "*"; } else { fromRole = entityName + "_" + property.Name; toRole = propertyType.Name + "_" + Inflector.Pluralize(entityName); relationship = fromRole + "_" + toRole; multiplicity = "0..1"; } entityElement.Add(new XElement( NsEdm + "NavigationProperty", new XAttribute("Name", property.Name), new XAttribute("Relationship", SchemaNamespace + "." + relationship), new XAttribute("FromRole", fromRole), new XAttribute("ToRole", toRole) )); XElement association; if (!associations.TryGetValue(relationship, out association)) { association = new XElement( NsEdm + "Association", new XAttribute("Name", relationship) ); associations.Add(relationship, association); } association.Add(new XElement( NsEdm + "End", new XAttribute("Role", toRole), new XAttribute("Type", SchemaNamespace + "." + propertyType.Name), new XAttribute("Multiplicity", multiplicity) )); } else { entityElement.Add(new XElement( NsEdm + "Property", new XAttribute("Name", property.Name), new XAttribute("Type", LiteralUtil.GetEdmType(propertyType)), new XAttribute("Nullable", property.IsNullable ? "true" : "false") )); } } entityContainerElement.Add(new XElement( NsEdm + "EntitySet", new XAttribute("Name", Inflector.Pluralize(entityName)), new XAttribute("EntityType", SchemaNamespace + "." + entityName) )); } foreach (var association in associations.Values) { schemaElement.Add(association); } schemaElement.Add(entityContainerElement); var document = new XDocument( new XElement( NsEdmx + "Edmx", new XAttribute(XNamespace.Xmlns + "edmx", NsEdmx), new XAttribute("Version", "1.0"), new XElement( NsEdmx + "DataServices", new XAttribute(XNamespace.Xmlns + "m", NsMetadata), new XAttribute(NsMetadata + "DataServiceVersion", "2.0"), schemaElement ) ) ); return(document.ToString(SaveOptions.DisableFormatting)); }
private void PrepareDataResponse() { DataServiceVersion = "2.0;"; string entityName; var path = new PathParser(_path).Parse(); if (path.Members.Count > 2) { throw new ODataException(ErrorMessages.PathParser_InvalidPath); } entityName = Inflector.Singularize(path.Members[path.Members.Count - 1].Name); IEnumerable entities; object parentEntity = null; string parentEntityName = Inflector.Singularize(path.Members[0].Name); if (path.Members[0].IdExpression != null) { object parentId = path.Members[0].IdExpression.Value; parentEntity = _session.Load(parentEntityName, parentId); } if (parentEntity != null && path.Members.Count == 1) { entities = new[] { parentEntity }; } else { var criteria = String.IsNullOrEmpty(_queryString) ? _session.CreateCriteria(entityName) : _session.ODataQuery(entityName, _queryString); if (path.Members.Count == 2) { if (parentEntity == null || path.Members[1].IdExpression != null) { throw new ODataException(ErrorMessages.PathParser_InvalidPath); } var parentPersister = _service.GetPersister(parentEntityName); var property = GetProperty(parentPersister, path.Members[1].Name); var collectionType = property.Type as CollectionType; var manyToOneType = property.Type as ManyToOneType; if (collectionType != null) { criteria.Add(Restrictions.Eq(parentEntityName, parentEntity)); } else if (manyToOneType != null) { /** * 01.06.2020: EntityMode.Poco removed; method GetPropertyValue supports only one parameter */ var childEntity = parentPersister.GetPropertyValue(parentEntity, property.Name /*, EntityMode.Poco*/); var childPersister = _service.GetPersister(property.Type.ReturnedClass); /** * 01.06.2020: EntityMode.Poco removed; method GetIdentifier supports only one parameter */ object idValue = childPersister.GetIdentifier(childEntity /*, EntityMode.Poco*/); criteria.Add(Restrictions.Eq(childPersister.IdentifierPropertyName, idValue)); } else { throw new ODataException(String.Format(ErrorMessages.ODataRequest_PropertyNotARelationship, path.Members[1].Name, parentPersister.EntityType.ReturnedClass.Name)); } } entities = criteria.List(); } var feedElement = new XElement( ODataService.NsAtom + "feed", new XAttribute(XNamespace.Xml + "base", _service.ServiceNamespace), new XAttribute(XNamespace.Xmlns + "d", ODataService.NsDataServices), new XAttribute(XNamespace.Xmlns + "m", ODataService.NsMetadata), new XAttribute("xmlns", ODataService.NsAtom), new XElement( ODataService.NsAtom + "title", new XAttribute("type", "text"), _path ), new XElement( ODataService.NsAtom + "id", _service.ServiceNamespace.ToString().TrimEnd('/') + "/" + _path ), new XElement( ODataService.NsAtom + "updated", DateTime.UtcNow.ToString("s") + "Z" ), new XElement( ODataService.NsAtom + "link", new XAttribute("rel", "self"), new XAttribute("title", _path), new XAttribute("href", _path) ) ); var persister = _service.GetPersister(entityName); foreach (var entity in entities) { var propertiesElement = new XElement( ODataService.NsMetadata + "properties" ); /** * 01.06.2020: EntityMode.Poco removed; method GetIdentifier supports only one parameter */ string id = Inflector.Pluralize(entityName) + "(" + LiteralUtil.EscapeValue(persister.GetIdentifier(entity /*, EntityMode.Poco*/)) + ")"; var entryElement = new XElement( ODataService.NsAtom + "entry", new XElement( ODataService.NsAtom + "id", _service.ServiceNamespace.ToString().TrimEnd('/') + "/" + id ), new XElement( ODataService.NsAtom + "author", new XElement(ODataService.NsAtom + "name") ) ); feedElement.Add(entryElement); /** * 01.06.2020: EntityMode.Poco removed; method GetIdentifier supports only one parameter */ propertiesElement.Add(AddProperty(persister.IdentifierPropertyName, persister.IdentifierType, persister.GetIdentifier(entity /*, EntityMode.Poco*/))); /** * 01.06.2020: EntityMode.Poco removed; method GetPropertyValues supports only one parameter */ var values = persister.GetPropertyValues(entity /*, EntityMode.Poco*/); for (int i = 0; i < values.Length; i++) { var propertyType = persister.PropertyTypes[i]; string propertyName = persister.PropertyNames[i]; var collectionType = propertyType as CollectionType; var manyToOneType = propertyType as ManyToOneType; if (collectionType != null || manyToOneType != null) { entryElement.Add(new XElement( ODataService.NsAtom + "link", new XAttribute("rel", ODataService.NsDataServices.ToString().TrimEnd('/') + "/related/" + propertyName), new XAttribute("type", "application/atom+xml;type=entry"), new XAttribute("title", propertyName), new XAttribute("href", id + "/" + propertyName) )); } else { propertiesElement.Add(AddProperty(propertyName, propertyType, values[i])); } } entryElement.Add( new XElement( ODataService.NsAtom + "category", new XAttribute("term", "SouthWind." + entityName), new XAttribute("schema", ODataService.NsDataServices) ) ); entryElement.Add( new XElement( ODataService.NsAtom + "content", new XAttribute("type", "application/xml"), propertiesElement ) ); } Response = new XDocument(feedElement).ToString(SaveOptions.DisableFormatting); }
public LiteralToken(object value) : this(value, LiteralUtil.GetLiteralType(value)) { // This overload is here just for unit testing. }