TableInfo.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;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Text;

using Deveel.Data.Serialization;
using Deveel.Data.Sql.Expressions;
using Deveel.Data.Transactions;
using Deveel.Data.Types;

namespace Deveel.Data.Sql.Tables {
    [Serializable]
    public sealed class TableInfo : IObjectInfo, IEnumerable<ColumnInfo>, ISerializable {
        private readonly IList<ColumnInfo> columns;
        private readonly Dictionary<ObjectName, int> columnsCache;

        public TableInfo(ObjectName tableName)
            : this(tableName, -1, false, new List<ColumnInfo>(), false) {
        }

        private TableInfo(ObjectName tableName, int id, bool perm, IList<ColumnInfo> columns, bool isReadOnly) {
            if (tableName == null) 
                throw new ArgumentNullException("tableName");

            TableName = tableName;
            Id = id;
            IsPermanent = perm;
            this.columns = columns;
            IsReadOnly = isReadOnly;

            columnsCache = new Dictionary<ObjectName, int>();
        }

        private TableInfo(ObjectData data) {
            TableName = data.GetValue<ObjectName>("TableName");
            Id = data.GetInt32("TableId");
            IsPermanent = data.GetBoolean("Permanent");
            IsReadOnly = data.GetBoolean("ReaDOnly");

            columns = new List<ColumnInfo>();
            var columnInfo = data.GetValue<ColumnInfo[]>("Columns");
            if (columnInfo != null) {
                foreach (var info in columnInfo) {
                    info.TableInfo = this;
                    columns.Add(info);
                }
            }

            columnsCache = new Dictionary<ObjectName, int>();
        }

        DbObjectType IObjectInfo.ObjectType {
            get { return DbObjectType.Table; }
        }

        public ObjectName TableName { get; private set; }

        ObjectName IObjectInfo.FullName {
            get { return TableName; }
        }

        public int Id { get; private set; }

        public bool IsPermanent { get; private set; }

        public string Name {
            get { return TableName.Name; }
        }

        public ObjectName SchemaName {
            get { return TableName.Parent; }
        }

        public string CatalogName {
            get { return SchemaName != null && SchemaName.Parent != null ? SchemaName.Parent.Name : null; }
        }

        //public bool IgnoreCase { get; set; }

        public bool IsReadOnly { get; private set; }

        public int ColumnCount {
            get { return columns.Count; }
        }

        public ColumnInfo this[int offset] {
            get {
                if (offset < 0 || offset >= columns.Count)
                    throw new ArgumentOutOfRangeException("offset");

                return columns[offset];
            }
        }

        private void AssertNotReadOnly() {
            if (IsReadOnly)
                throw new InvalidOperationException();
        }

        public void Establish(int id) {
            Id = id;
            IsPermanent = true;
        }

        void ISerializable.GetData(SerializeData data) {
            data.SetValue("TableName", TableName);
            data.SetValue("TableId", Id);
            data.SetValue("ReadOnly", IsReadOnly);
            data.SetValue("Permanent", IsPermanent);
            data.SetValue("Columns", columns.ToArray());
        }

        internal void AddColumnSafe(ColumnInfo column) {
            if (column == null)
                throw new ArgumentNullException("column");

            AssertNotReadOnly();

            columnsCache.Clear();
            column.TableInfo = this;
            columns.Add(column);
        }

        public void AddColumn(ColumnInfo column) {
            if (column == null)
                throw new ArgumentNullException("column");

            AssertNotReadOnly();

            if (column.TableInfo != null &&
                column.TableInfo != this)
                throw new ArgumentException(String.Format("The column {0} belongs to another table already ({1})", column.ColumnName,
                    column.TableInfo.Name));

            if (columns.Any(x => x.ColumnName == column.ColumnName))
                throw new ArgumentException(String.Format("Column {0} is already defined in table {1}", column.ColumnName, TableName));

            columnsCache.Clear();
            column.TableInfo = this;
            columns.Add(column);
        }

        public ColumnInfo AddColumn(string columnName, SqlType columnType) {
            return AddColumn(columnName, columnType, false);
        }

        public ColumnInfo AddColumn(string columnName, SqlType columnType, bool notNull) {
            if (String.IsNullOrEmpty(columnName))
                throw new ArgumentNullException("columnName");

            if (columnType == null)
                throw new ArgumentNullException("columnType");

            var column = new ColumnInfo(columnName, columnType);
            column.IsNotNull = notNull;
            AddColumn(column);
            return column;
        }

        public IEnumerator<ColumnInfo> GetEnumerator() {
            return columns.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            return GetEnumerator();
        }

        public int IndexOfColumn(string columnName) {
            return IndexOfColumn(new ObjectName(TableName, columnName));
        }

        public int IndexOfColumn(ObjectName columnName) {
            int index;
            if (!columnsCache.TryGetValue(columnName, out index)) {
                bool found = false;
                for (int i = 0; i < columns.Count; i++) {
                    var column = columns[i];
                    if (column.ColumnName.Equals(columnName.Name, StringComparison.Ordinal)) {
                        index = i;
                        columnsCache[columnName] = index;
                        found = true;
                    }
                }

                if (!found)
                    index = -1;
            }

            return index;
        }

        public TableInfo AsReadOnly() {
            return new TableInfo(TableName, Id, IsPermanent, new ReadOnlyCollection<ColumnInfo>(columns), true);
        }

        public TableInfo Alias(ObjectName alias) {
            return new TableInfo(alias, Id, IsPermanent, new ReadOnlyCollection<ColumnInfo>(columns), true);
        }

        internal SqlExpression ResolveColumns(bool ignoreCase, SqlExpression expression) {
            var visitor = new ColumnsResolver(this, ignoreCase);
            return visitor.Visit(expression);
        }

        class ColumnsResolver : SqlExpressionVisitor {
            private readonly TableInfo tableInfo;
            private readonly bool ignoreCase;

            public ColumnsResolver(TableInfo tableInfo, bool ignoreCase) {
                this.tableInfo = tableInfo;
                this.ignoreCase = ignoreCase;
            }

            public override SqlExpression VisitReference(SqlReferenceExpression reference) {
                var exp = reference;

                var colName = exp.ReferenceName.Name;
                var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

                foreach (var columnInfo in tableInfo) {
                    if (String.Equals(colName, columnInfo.ColumnName, comparison)) {
                        exp = SqlExpression.Reference(new ObjectName(tableInfo.TableName, columnInfo.ColumnName));
                    }
                }

                return exp;
            }
        }

        public IEnumerable<int> IndexOfColumns(IEnumerable<string> columnNames) {
            if (columnNames == null)
                return new int[0];

            return columnNames.Select(IndexOfColumn).ToArray();
        }

        public static void Serialize(TableInfo tableInfo, Stream stream) {
            var writer = new BinaryWriter(stream, Encoding.Unicode);
            Serialize(tableInfo, writer);
        }

        public static void Serialize(TableInfo tableInfo, BinaryWriter writer) {
            writer.Write(3);    // Version

            var catName = tableInfo.CatalogName;
            if (catName == null)
                catName = String.Empty;

            writer.Write(catName);
            writer.Write(tableInfo.SchemaName.Name);
            writer.Write(tableInfo.Name);

            var colCount = tableInfo.columns.Count;
            writer.Write(colCount);
            for (int i = 0; i < colCount; i++) {
                var column = tableInfo.columns[i];
                ColumnInfo.Serialize(column, writer);
            }
        }

        public static TableInfo Deserialize(Stream stream, ITypeResolver typeResolver) {
            var reader = new BinaryReader(stream, Encoding.Unicode);
            return Deserialize(reader, typeResolver);
        }

        public static TableInfo Deserialize(BinaryReader reader, ITypeResolver typeResolver) {
            var version = reader.ReadInt32();
            if (version != 3)
                throw new FormatException("Invalid version of the table info.");

            var catName = reader.ReadString();
            var schemName = reader.ReadString();
            var tableName = reader.ReadString();

            var objSchemaName = !String.IsNullOrEmpty(catName)
                ? new ObjectName(new ObjectName(catName), schemName)
                : new ObjectName(schemName);

            var objTableName = new ObjectName(objSchemaName, tableName);

            var tableInfo = new TableInfo(objTableName);

            var colCount = reader.ReadInt32();
            for (int i = 0; i < colCount; i++) {
                var columnInfo = ColumnInfo.Deserialize(reader, typeResolver);

                if (columnInfo != null)
                    tableInfo.AddColumn(columnInfo);
            }

            return tableInfo;
        }
    }
}