SqlType.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2015 Deveel
// 
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
// 
//        http://www.apache.org/licenses/LICENSE-2.0
// 
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
//

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

using Deveel.Data.Serialization;
using Deveel.Data.Sql.Parser;
using Deveel.Data.Sql.Objects;
using Deveel.Data.Store;

namespace Deveel.Data.Types {
    [Serializable]
    public abstract class SqlType : IComparer<ISqlObject>, IEquatable<SqlType>, ISerializable {
        protected SqlType(SqlTypeCode sqlType)
            : this(sqlType.ToString().ToUpperInvariant(), sqlType) {
        }

        protected SqlType(string name, SqlTypeCode typeCode) {
            TypeCode = typeCode;
            Name = name;
        }

        protected SqlType(ObjectData data) {
            Name = data.GetString("Name");
            TypeCode = (SqlTypeCode) data.GetInt32("TypeCode");
        }

        public string Name { get; private set; }

        public SqlTypeCode TypeCode { get; private set; }

        public virtual bool IsIndexable {
            get { return true; }
        }

        public bool IsPrimitive {
            get { return IsPrimitiveType(TypeCode); }
        }

        public bool IsNull {
            get { return TypeCode == SqlTypeCode.Null; }
        }

        public virtual bool IsStorable {
            get { return false; }
        }

        public virtual bool IsComparable(SqlType type) {
            return TypeCode == type.TypeCode;
        }

        public virtual bool CanCastTo(SqlType destType) {
            return false;
        }

        public virtual DataObject CastTo(DataObject value, SqlType destType) {
            if (Equals(destType))
                return value;

            // TODO: Should we return a null value instead? NULL OF TYPE anyway is still a cast ...
            throw new NotSupportedException();
        }

        public virtual object ConvertTo(ISqlObject obj, Type destType) {
            throw new NotSupportedException();
        }

        public virtual ISqlObject Add(ISqlObject a, ISqlObject b) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Subtract(ISqlObject a, ISqlObject b) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Multiply(ISqlObject a, ISqlObject b) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Divide(ISqlObject a, ISqlObject b) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Modulus(ISqlObject a, ISqlObject b) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Negate(ISqlObject value) {
            return SqlNull.Value;
        }

        public virtual SqlBoolean IsEqualTo(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) == 0;
        }

        public virtual SqlBoolean IsNotEqualTo(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) != 0;
        }

        public virtual SqlBoolean IsGreatherThan(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) > 0;
        }

        public virtual SqlBoolean IsSmallerThan(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) < 0;
        }

        public virtual SqlBoolean IsGreaterOrEqualThan(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) >= 0;
        }

        public virtual SqlBoolean IsSmallerOrEqualThan(ISqlObject a, ISqlObject b) {
            if (!a.IsComparableTo(b))
                return SqlBoolean.Null;

            return a.CompareTo(b) <= 0;
        }

        public virtual ISqlObject And(ISqlObject a, ISqlObject b) {
            return SqlBoolean.Null;
        }

        public virtual ISqlObject Or(ISqlObject a, ISqlObject b) {
            return SqlBoolean.Null;
        }

        public virtual ISqlObject XOr(ISqlObject x, ISqlObject y) {
            return SqlNull.Value;
        }

        public virtual ISqlObject UnaryPlus(ISqlObject value) {
            return SqlNull.Value;
        }

        public virtual ISqlObject Reverse(ISqlObject value) {
            return SqlNull.Value;
        }

        void ISerializable.GetData(SerializeData data) {
            data.SetValue("Name", Name);
            data.SetValue("TypeCode", (int) TypeCode);
        }

        protected virtual void GetData(SerializeData data) {
        }

        public virtual SqlType Wider(SqlType otherType) {
            return this;
        }

        public static SqlType Parse(string s) {
            return Parse(null, s);
        }

        public static SqlType Parse(IContext context, string s) {
            var sqlCompiler = SqlParsers.DataType;

            try {
                var result = sqlCompiler.Parse(s);
                if (result.HasErrors)
                    throw new SqlParseException(result.Errors.First().Message);

                var node = (DataTypeNode) result.RootNode;

                if (context == null && !node.IsPrimitive)
                    throw new NotSupportedException(String.Format("The type '{0}' is not primitive and no resolve context is provided.", node.TypeName));

                return DataTypeBuilder.Build(context.TypeResolver(), node);
            } catch (SqlParseException) {
                throw new FormatException("Unable to parse the given string to a valid data type.");
            }
        }

        public virtual int Compare(ISqlObject x, ISqlObject y) {
            if (!x.IsComparableTo(y))
                throw new NotSupportedException();

            if (x.IsNull && y.IsNull)
                return 0;
            if (x.IsNull && !y.IsNull)
                return 1;
            if (!x.IsNull && y.IsNull)
                return -1;

            return ((IComparable) x).CompareTo(y);
        }

        public override bool Equals(object obj) {
            var dataType = obj as SqlType;
            if (dataType == null)
                return false;

            return Equals(dataType);
        }

        public override int GetHashCode() {
            return TypeCode.GetHashCode();
        }

        public virtual bool Equals(SqlType other) {
            if (other == null)
                return false;

            return TypeCode == other.TypeCode;
        }

        public override string ToString() {
            return Name;
        }

        public virtual void SerializeObject(Stream stream, ISqlObject obj) {
            throw new NotSupportedException(String.Format("Type {0} cannot serialize object of type {1}.", GetType(),
                obj.GetType()));
        }

        public virtual ISqlObject DeserializeObject(Stream stream) {
            throw new NotSupportedException(String.Format("Type {0} cannot deserialize types.", GetType()));
        }

        public virtual bool IsCacheable(ISqlObject value) {
            return false;
        }

        internal virtual int GetCacheUsage(ISqlObject value) {
            return 0;
        }

        internal virtual int ColumnSizeOf(ISqlObject obj) {
            // TODO: should make this required?
            return 0;
        }

        public virtual Type GetRuntimeType() {
            throw new NotSupportedException();
        }

        public virtual Type GetObjectType() {
            throw new NotSupportedException();
        }

        public virtual ISqlObject CreateFromLargeObject(ILargeObject objRef) {
            throw new NotSupportedException(String.Format("SQL Type {0} cannot be created from a large object.", TypeCode));
        }

        public static bool IsPrimitiveType(SqlTypeCode typeCode) {
            return PrimitiveTypes.IsPrimitive(typeCode);
        }

        public virtual ISqlObject CreateFrom(object value) {
            throw new NotSupportedException(String.Format("The type {0} does not support runtime object conversion.", ToString()));
        }

        public static SqlType Resolve(SqlTypeCode typeCode) {
            return Resolve(typeCode, new DataTypeMeta[0]);
        }

        public static SqlType Resolve(SqlTypeCode typeCode, DataTypeMeta[] meta) {
            return Resolve(typeCode, meta, null);
        }

        public static SqlType Resolve(SqlTypeCode typeCode, DataTypeMeta[] meta, ITypeResolver resolver) {
            return Resolve(typeCode, typeCode.ToString().ToUpperInvariant(), meta, resolver);
        }

        public static SqlType Resolve(SqlTypeCode typeCode, string name) {
            return Resolve(typeCode, name, new DataTypeMeta[0]);
        }

        public static SqlType Resolve(SqlTypeCode typeCode, string name, DataTypeMeta[] meta) {
            return Resolve(typeCode, name, meta, null);
        }

        public static SqlType Resolve(string name) {
            return Resolve(name, new DataTypeMeta[0]);
        }

        public static SqlType Resolve(string name, DataTypeMeta[] meta) {
            return Resolve(name, meta, null);
        }

        public static SqlType Resolve(string name, DataTypeMeta[] meta, ITypeResolver resolver) {
            var typeCode = ResolveTypeCode(name);
            return Resolve(typeCode, name, meta, resolver);
        }

        public static SqlType Resolve(SqlTypeCode typeCode, string name, DataTypeMeta[] meta, ITypeResolver resolver) {
            return TypeResolver.Resolve(typeCode, name, meta, resolver);
        }

        private static SqlTypeCode ResolveTypeCode(string name) {
            var typeCode = PrimitiveTypes.ResolveTypeCode(name);
            if (typeCode == SqlTypeCode.Unknown)
                typeCode = SqlTypeCode.Type;

            return typeCode;
        }
    }
}