DataTypeNode.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.Linq;

using Deveel.Data.Sql.Objects;
using Deveel.Data.Types;

namespace Deveel.Data.Sql.Parser {
    class DataTypeNode : SqlNode {
        internal DataTypeNode() {
            IsPrimitive = true;
            Metadata = new Dictionary<string, string>();
        }

        public bool IsPrimitive { get; private set; }

        public string TypeName { get; private set; }

        public int Size { get; private set; }

        public bool HasSize { get; private set; }

        public int Scale { get; private set; }

        public bool HasScale { get; private set; }

        public int Precision { get; private set; }

        public bool HasPrecision { get; private set; }

        public string Locale { get; private set; }

        public bool HasLocale { get; private set; }

        public string Encoding { get; private set; }

        public bool HasEncoding { get; private set; }

        public Dictionary<string, string> Metadata { get; private set; } 

        protected override ISqlNode OnChildNode(ISqlNode node) {
            if (node.NodeName == "identity_type") {
                TypeName = "IDENTITY";
            } else if (node.NodeName == "boolean_type") {
                GetBooleanType(node);
            } else if (node.NodeName == "decimal_type") {
                GetNumberType(node);
            } else if (node.NodeName == "character_type" ||
                       node.NodeName == "binary_type") {
                GetSizedType(node);
            } else if (node.NodeName == "date_type" ||
                       node.NodeName == "integer_type" ||
                       node.NodeName == "float_type") {
                GetSimpleType(node);
            } else if (node.NodeName == "interval_type") {
            } else if (node.NodeName == "user_type") {
                GetUserType(node);
            } else if (node.NodeName == "row_type") {

            }

            return base.OnChildNode(node);
        }

        private void GetBooleanType(ISqlNode node) {
            IsPrimitive = true;
            TypeName = "BOOLEAN";
        }

        private void GetUserType(ISqlNode node) {
            IsPrimitive = false;
            TypeName = node.FindNode<ObjectNameNode>().Name;
            var optMetaList = node.FindByName("user_type_meta_opt");
            if (optMetaList != null) {
                GetMeta(optMetaList.ChildNodes.FirstOrDefault());
            }
        }

        private void GetMeta(ISqlNode node) {
            if (node == null)
                return;

            var metas = node.FindNodes<DataTypeMetaNode>();
            foreach (var meta in metas) {
                Metadata[meta.Name] = meta.Value;
            }
        }

        private void GetSimpleType(ISqlNode node) {
            var type = node.ChildNodes.First();
            TypeName = type.NodeName;
        }

        private void GetSizedType(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (childNode.NodeName == "long_varchar") {
                    TypeName = "LONG VARCHAR";
                } else if (childNode is SqlKeyNode) {
                    TypeName = ((SqlKeyNode) childNode).Text;
                } else if (childNode.NodeName == "datatype_size") {
                    GetDataSize(childNode);
                } else if (childNode.NodeName == "locale_opt") {
                    GetLocale(childNode);
                } else if (childNode.NodeName == "encoding_opt") {
                    GetEncoding(childNode);
                }
            }
        }

        private void GetLocale(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (childNode is StringLiteralNode) {
                    Locale = ((StringLiteralNode) childNode).Value;
                    HasLocale = true;
                }
            }
        }

        private void GetEncoding(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (childNode is StringLiteralNode) {
                    Encoding = ((StringLiteralNode) childNode).Value;
                    HasEncoding = true;
                }
            }
        }

        private void GetDataSize(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (childNode is IntegerLiteralNode) {
                    Size = (int) ((IntegerLiteralNode) childNode).Value;
                    HasSize = true;
                }
            }
        }

        private void GetNumberType(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (childNode is SqlKeyNode) {
                    TypeName = ((SqlKeyNode) childNode).Text;
                } else if (childNode.NodeName == "number_precision") {
                    GetNumberPrecision(childNode);
                }
            }

        }

        private void GetNumberPrecision(ISqlNode node) {
            foreach (var childNode in node.ChildNodes) {
                if (!HasScale) {
                    Scale = (int) ((IntegerLiteralNode) childNode).Value;
                    HasScale = true;
                } else {
                    Precision = (int) ((IntegerLiteralNode) childNode).Value;
                    HasPrecision = true;
                }
            }
        }
    }
}