Row.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.Expressions;
using Deveel.Data.Sql.Objects;
using Deveel.Data.Types;

namespace Deveel.Data.Sql.Tables {
    public sealed class Row : IDbObject {
        private RowVariableResolver variableResolver;
        private Dictionary<int, DataObject> values;

        public Row(ITable table, RowId rowId) {
            if (table == null)
                throw new ArgumentNullException("table");

            if (!rowId.IsNull &&
                table.TableInfo.Id >= 0 &&
                table.TableInfo.Id != rowId.TableId)
                throw new ArgumentException(String.Format("The table ID {0} does not match the identifier specified by the row ID ({1})",
                    table.TableInfo.Id,
                    rowId.TableId));

            Table = table;
            RowId = rowId;
        }

        public Row(ITable table, int rowNumber)
            : this(table, new RowId(table.TableInfo.Id, rowNumber)) {
        }

        public Row(ITable table)
            : this(table, RowId.Null) {
        }

        public ITable Table { get; private set; }

        public RowId RowId { get; private set; }

        ObjectName IDbObject.FullName {
            get { return new ObjectName(Table.FullName, RowId.RowNumber.ToString());}
        }

        DbObjectType IDbObject.ObjectType {
            get { return DbObjectType.Row; }
        }

        public DataObject this[int columnOffset] {
            get { return GetValue(columnOffset); }
            set { SetValue(columnOffset, value); }
        }

        public DataObject this[string columnName] {
            get { return GetValue(columnName); }
            set { SetValue(columnName, value); }
        }

        private IVariableResolver VariableResolver {
            get {
                if (variableResolver == null) {
                    variableResolver = new RowVariableResolver(this);
                } else {
                    variableResolver.NextAssignment();
                }
                return variableResolver;
            }
        }

        public int ColumnCount {
            get { return Table.TableInfo.ColumnCount; }
        }

        public bool Exists {
            get { return Table.Any(x => x.RowId.Equals(RowId)); }
        }

        private bool? canBeCached;

        public bool CanBeCached {
            get {
                if (canBeCached == null) {
                    canBeCached = values.All(value => value.Value.IsCacheable);
                }

                return canBeCached.Value;
            }
        }


        public DataObject GetValue(int columnOffset) {
            if (columnOffset < 0 || columnOffset >= Table.TableInfo.ColumnCount)
                throw new ArgumentOutOfRangeException("columnOffset");

            if (values == null) {
                if (RowId.IsNull)
                    throw new InvalidOperationException("Row was not established to any table.");

                var colCount = Table.TableInfo.ColumnCount;
                values = new Dictionary<int, DataObject>(colCount);

                for (int i = 0; i < colCount; i++) {
                    values[i] = Table.GetValue(RowId.RowNumber, i);
                }
            }

            DataObject value;
            if (!values.TryGetValue(columnOffset, out value)) {
                var columnType = Table.TableInfo[columnOffset].ColumnType;
                return DataObject.Null(columnType);
            }

            return value;
        }

        public void SetValue(int columnOffset, DataObject value) {
            var colCount = Table.TableInfo.ColumnCount;

            if (columnOffset < 0 || columnOffset >= Table.TableInfo.ColumnCount)
                throw new ArgumentOutOfRangeException("columnOffset");

            if (values == null)
                values = new Dictionary<int, DataObject>(colCount);

            var column = Table.TableInfo[columnOffset];
            var columnType = column.ColumnType;

            if (!value.Type.IsComparable(columnType)) {
                throw new ArgumentException(
                    String.Format("The specified value of type '{0}' is not comparable to '{1}' defined by '{2}'.",
                        value.Type, columnType, column.FullColumnName));
            }

            values[columnOffset] = value;
        }

        public DataObject GetValue(string columnName) {
            if (String.IsNullOrEmpty(columnName))
                throw new ArgumentNullException("columnName");

            var offset = Table.TableInfo.IndexOfColumn(columnName);
            if (offset < 0)
                throw new ArgumentException(String.Format("Could not find column '{0}' in the table '{1}'.", columnName, Table.FullName));

            return GetValue(offset);
        }

        public void SetValue(string columnName, DataObject value) {
            if (String.IsNullOrEmpty(columnName))
                throw new ArgumentNullException("columnName");

            var offset = Table.TableInfo.IndexOfColumn(columnName);
            if (offset < 0)
                throw new ArgumentException(String.Format("Could not find column '{0}' in the table '{1}'.", columnName, Table.FullName));

            SetValue(offset, value);
        }

        public void SetValue(int columnIndex, string value) {
            SetValue(columnIndex, DataObject.String(value));
        }

        public void SetValue(int columnIndex, int value) {
            SetValue(columnIndex, DataObject.Integer(value));
        }

        public void SetValue(int columnIndex, long value) {
            SetValue(columnIndex, DataObject.BigInt(value));
        }

        public void SetValue(int columnIndex, short value) {
            SetValue(columnIndex, DataObject.SmallInt(value));
        }

        public void SetValue(int columnIndex, float value) {
            SetValue(columnIndex, new SqlNumber(value));
        }

        public void SetValue(int columnIndex, double value) {
            SetValue(columnIndex, DataObject.Number(new SqlNumber(value)));
        }

        public void SetValue(int columnIndex, SqlNumber value) {
            SetValue(columnIndex, DataObject.Number(value));
        }

        public void SetValue(int columnIndex, bool value) {
            SetValue(columnIndex, DataObject.Boolean(value));
        }

        public void SetValue(int columnIndex, byte[] bytes) {
            SetValue(columnIndex, DataObject.Binary(bytes));
        }

        public void SetValue(int columnIndex, SqlBinary binary) {
            SetValue(columnIndex, DataObject.Binary(binary));
        }

        public void SetNull(int columnOffset) {
            if (columnOffset < 0 || columnOffset >= Table.TableInfo.ColumnCount)
                throw new ArgumentOutOfRangeException("columnOffset");

            var columnType = Table.TableInfo[columnOffset].ColumnType;
            SetValue(columnOffset, new DataObject(columnType, null));
        }

        public void SetDefault(int columnOffset, IQuery context) {
            if (columnOffset < 0 || columnOffset >= Table.TableInfo.ColumnCount)
                throw new ArgumentOutOfRangeException("columnOffset");

            var column = Table.TableInfo[columnOffset];
            if (!column.HasDefaultExpression)
                throw new InvalidOperationException(String.Format("Column '{0}' in table '{1}' has no DEFAULT set.", column.ColumnName, Table.FullName));

            var value = Evaluate(column.DefaultExpression, context);
            SetValue(columnOffset, value);
        }

        public void SetDefault(IQuery context) {
            for (int i = 0; i < Table.TableInfo.ColumnCount; ++i) {
                if (!values.ContainsKey(i)) {
                    SetDefault(i, context);
                }
            }
        }

        private DataObject Evaluate(SqlExpression expression, IQuery queryContext) {
            var ignoreCase = queryContext.IgnoreIdentifiersCase();
            // Resolve any variables to the table_def for this expression.
            expression = Table.TableInfo.ResolveColumns(ignoreCase, expression);
            // Get the variable resolver and evaluate over this data.
            IVariableResolver vresolver = VariableResolver;
            var reduced = expression.Evaluate(queryContext, vresolver, null);
            if (reduced.ExpressionType != SqlExpressionType.Constant)
                throw new InvalidOperationException("The DEFAULT expression of the column cannot be reduced to a constant");

            return ((SqlConstantExpression) reduced).Value;
        }

        public void SetNumber(int number) {
            RowId = new RowId(Table.TableInfo.Id, number);
        }

        #region RowVariableResolver

        private class RowVariableResolver : IVariableResolver {
            private readonly Row row;
            private int assignmentCount;

            public RowVariableResolver(Row row) {
                this.row = row;
            }

            internal void NextAssignment() {
                ++assignmentCount;
            }

            public int SetId {
                get { return assignmentCount; }
            }

            public DataObject Resolve(ObjectName columnName) {
                string colName = columnName.Name;

                int colIndex = row.Table.TableInfo.IndexOfColumn(colName);
                if (colIndex == -1)
                    throw new InvalidOperationException(String.Format("Column '{0}' could not be found in table '{1}'", colName, row.Table.FullName));

                DataObject value;
                if (!row.values.TryGetValue(colIndex, out value))
                    throw new InvalidOperationException("Column " + colName + " hasn't been set yet.");

                return value;
            }

            public SqlType ReturnType(ObjectName columnName) {
                string colName = columnName.Name;

                int colIndex = row.Table.TableInfo.IndexOfColumn(colName);
                if (colIndex == -1)
                    throw new InvalidOperationException("Can't find column: " + colName);

                return row.Table.TableInfo[colIndex].ColumnType;
            }
        }

        #endregion

        public void SetRowNumber(int rowNumber) {
            RowId = new RowId(Table.TableInfo.Id, rowNumber);
        }

        public void SetFromTable() {
            for (int i = 0; i < Table.TableInfo.ColumnCount; i++) {
                SetValue(i, Table.GetValue(RowId.RowNumber, i));
            }
        }

        public void EvaluateAssignment(SqlAssignExpression assignExpression, IQuery context) {
            var colRef = (SqlReferenceExpression) assignExpression.ReferenceExpression;
            var valueExp = assignExpression.ValueExpression;
            var value = valueExp.EvaluateToConstant(context, VariableResolver);

            // Check the column name is within this row.
            var columnName = colRef.ReferenceName;
            int column = Table.FindColumn(columnName);

            if (column == -1)
                throw new ObjectNotFoundException(columnName,
                    String.Format("Table '{0}' has none column named '{1}': cannot assign.", Table.TableInfo.TableName, columnName));

            SetValue(column, value);
        }
    }
}