/// <summary>
        /// Executes the function on myCallingObject
        /// </summary>
        public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
        {
            var currentInnerEdgeType = ((IOutgoingEdgeDefinition)myAttributeDefinition).InnerEdgeType;

            if (myCallingObject is IHyperEdge && currentInnerEdgeType.HasProperty("Weight"))
            {
                var hyperEdge = myCallingObject as IHyperEdge;

                if (currentInnerEdgeType.HasProperty("Weight"))
                {
                    var weightProperty = currentInnerEdgeType.GetPropertyDefinition("Weight");

                    var maxWeight = hyperEdge.InvokeHyperEdgeFunc<Double>(singleEdges =>
                    {
                        return Convert.ToDouble(
                            weightProperty.GetValue(
                            singleEdges
                            .OrderByDescending(edge => weightProperty.GetValue(edge))
                            .First()));
                    });

                    return new FuncParameter(maxWeight);

                }
            }

            throw new InvalidTypeException(myCallingObject.GetType().ToString(), "Weighted IHyperEdge");
        }

        private IAttributeDefinition ResolveAttribute(string token, IAttributeDefinition result) {
            if(result == null && token != null) {
                result = meta.GetAttributeDefinition(token);
            }

            return result;
        }

 public SelectionElement(string myAlias, Select.EdgeList myEdgeList, bool myIsGroupedOrAggregated, IDChainDefinition myRelatedIDChainDefinition, IAttributeDefinition myElement = null)
     : this(myAlias, myRelatedIDChainDefinition)
 {
     EdgeList = myEdgeList;
     IsGroupedOrAggregated = myIsGroupedOrAggregated;
     Element = myElement;
 }

        public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
        {
            if (!(myCallingObject is String))
            {
                throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
            }

            var pos = Convert.ToInt32(myParams[0].Value);

            StringBuilder resString = new StringBuilder();
            bool dontInsert = false;

            if (pos > (myCallingObject as String).Length)
            {
                dontInsert = true;
                resString.Append((myCallingObject as String).ToString());
            }
            else
            {
                resString.Append((myCallingObject as String).ToString().Substring(0, pos));
            }

            foreach (FuncParameter fp in myParams.Skip(1))
            {
                resString.Append(fp.Value as String);
            }

            if(!dontInsert)
                resString.Append((myCallingObject as String).ToString().Substring(pos));

            return new FuncParameter(resString.ToString());
        }

 public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
 {
     if (myCallingObject is IHyperEdge)
     {
         return new FuncParameter((UInt64)((IHyperEdge)myCallingObject).GetAllEdges().Count());
     }
     else if (myCallingObject is ISingleEdge)
     {
         UInt64 count = 1;
         return new FuncParameter(count);
     }
     else if (myCallingObject is IncomingEdgeCollection)
     {
         return new FuncParameter((UInt64)(myCallingObject as IncomingEdgeCollection).LongCount());
     }
     else if (myCallingObject is IEnumerable<long>)
     {
         return new FuncParameter((UInt64)(myCallingObject as IEnumerable<long>).LongCount());
     }
     else if (myCallingObject is IEnumerable<IVertex>)
     {
         return new FuncParameter((UInt64)(myCallingObject as IEnumerable<IVertex>).LongCount());
     }
     else
     {
         throw new UnknownDBException("Unexpected input for COUNT aggregate.");
     }
 }

		private int IndexOf(IAttributeDefinition attribdef)
		{
			for (int i=0;i<_terms.Count;i++)
				if (_terms[i].AttributeDefinition == attribdef)
					return i;
			return -1;
		}

		private void Remove(IAttributeDefinition attribdef)
		{
			int index = IndexOf(attribdef);
			if (index == -1)
				return;
			_terms.RemoveAt(index);
		}

 /// <summary>
 /// Clear an attribute from cache based on definition.
 /// </summary>
 /// <param name="attribdef">definition of attribute to clear; 
 /// if null, all attributes will be cleared from cache.</param>
 public void ClearAttributeCache(IAttributeDefinition attribdef) {
     if (attribdef == null) {
         attributes.Clear();
     } else {
         attributes.Remove(ResolveAttributeDefinition(attribdef).Token);
     }
 }

 public virtual void SetValue(IAttributeDefinition attrDef, object value)
 {
     Type it = this.GetType();//this.GetType().Assembly.GetType("TJVISA.Entity." + attrDef.ForObject.EntityName,false, true);
     if (it == null) Debug.Assert(false, attrDef.ForObject.EntityName + " is unknown object type.");
     PropertyInfo p = it.GetProperty(attrDef.Name);
     if (p != null && p.CanWrite)
         p.SetValue(this, value, null);
 }

        private IAttributeDefinition ResolveAttributeDefinition(IAttributeDefinition attribdef) {
            try {
                if(AssetType.Is(attribdef.AssetType)) {
                    return AssetType.GetAttributeDefinition(attribdef.Name);
                }
            } catch (MetaException) { }

            return attribdef;
        }

 public virtual object GetValue(IAttributeDefinition attrDef)
 {
     Type it = this.GetType();//this.GetType().Assembly.GetType("TJVISA.Entity." + attrDef.ForObject.EntityName,false, true);
     if (it == null) Debug.Assert(false, attrDef.ForObject.EntityName+ " is unknown object type.");
     PropertyInfo p = it.GetProperty(attrDef.Name);
     if (p != null && p.CanRead)
         return p.GetValue(this, null);
     return null;
 }

        public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
        {
            if (!(myCallingObject is String))
            {
                throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
            }

            var substring = myCallingObject.ToString().Substring(Convert.ToInt32(myParams[0].Value), Convert.ToInt32(myParams[1].Value));

            return new FuncParameter(substring);
        }

 public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
 {
     if (myCallingObject is String)
     {
         return new FuncParameter(((String)myCallingObject).ToLower());
     }
     else
     {
         throw new FunctionParameterTypeMismatchException(typeof(String), myCallingObject.GetType());
     }
 }

 public ServiceAttributeDefinition(IAttributeDefinition myAttributeDefinition)
 {
     if (myAttributeDefinition != null)
     {
         this.ID = myAttributeDefinition.ID;
         this.Name = myAttributeDefinition.Name;
         this.IsUserDefined = myAttributeDefinition.IsUserDefined;
         this.Kind = (ServiceAttributeType)myAttributeDefinition.Kind;
         this.RelatedType = ConvertHelper.ToServiceBaseType(myAttributeDefinition.RelatedType);
     }
 }

 public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
 {
     if (myCallingObject != null)
     {
         return new FuncParameter(true);
     }
     else
     {
         return new FuncParameter(false);
     }
 }

        /// <summary>
        /// Validate single Asset attribute. If attribute is not loaded, it is just considered invalid.
        /// </summary>
        /// <param name="asset">Asset to validate</param>
        /// <param name="attributeDefinition">Attribute definition of validated attribute</param>
        /// <returns>Validation result</returns>
        // TODO create separate private method to avoid excessive GetRequiredFields() calls
        public bool Validate(Asset asset, IAttributeDefinition attributeDefinition)
        {
            GetRequiredFields(asset.AssetType);
            asset.EnsureAttribute(attributeDefinition);
            Attribute attribute = asset.GetAttribute(attributeDefinition);
            bool result = attribute != null && !(IsMultiValueAndUnfilled(attribute) || IsSingleValueAndUnfilled(attribute));

            if (!result && attribute != null)
            {
                result = !attribute.HasChanged && !isAttributeUnfilledOnServer(asset, attributeDefinition);
            }

            return result;
        }

        internal OrderBy BuildOrderBy(IAssetType assetType, IAttributeDefinition defaultOrderBy) {
            var order = new OrderBy();
            
            if (OrderBy.Count > 0) {
                foreach(var s in OrderBy) {
                    order.MinorSort(assetType.GetAttributeDefinition(ResolvePropertyName(s)), APIClient.OrderBy.Order.Ascending);
                }
            } else {
                if(defaultOrderBy != null) {
                    order.MinorSort(defaultOrderBy, APIClient.OrderBy.Order.Ascending);
                }
            }

            return order;
        }

 public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken, params FuncParameter[] myParams)
 {
     if (myCallingObject is UInt64)
     {
         var dtValue = Convert.ToDateTime((UInt64)myCallingObject);
         return new FuncParameter((Int64)UNIXTimeConversionExtension.ToUnixTimeStamp(dtValue));
     }
     else if (myCallingObject is DateTime)
     {
         return new FuncParameter(UNIXTimeConversionExtension.ToUnixTimeStamp((DateTime)myCallingObject));
     }
     else
     {
         throw new InvalidTypeException(myCallingObject.GetType().ToString(), "DateTime");
     }
 }

        public Query(IAssetType assetType, bool historical, IAttributeDefinition parentRelation) {
            Find = null;
            this.assetType = assetType;
            isHistorical = historical;
            oid = Oid.Null;
            this.parentRelation = parentRelation;
            
            if (this.parentRelation != null) {
                if(this.parentRelation.AttributeType != AttributeType.Relation) {
                    throw new ApplicationException("Parent Relation must be a Relation Attribute Type");
                }

                if(this.parentRelation.IsMultiValue) {
                    throw new ApplicationException("Parent Relation cannot be multi-value");
                }
            }
        }

 public override FuncParameter ExecFunc(IAttributeDefinition myAttributeDefinition, Object myCallingObject, IVertex myDBObject, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken, params FuncParameter[] myParams)
 {
     if (myCallingObject != null)
     {
         if (myCallingObject is Int64)
         {
             return new FuncParameter(UNIXTimeConversionExtension.FromUnixTimeStamp((Int64)myCallingObject));
         }
         else
         {
             throw new InvalidTypeException(myCallingObject.GetType().Name, "Int64");
         }
     }
     else
     {
         throw new NotImplementedException();
     }
 }