QueryResult.old.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2014 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 Deveel.Data.DbSystem;

namespace Deveel.Data.Protocol {
    public sealed class QueryResult : IDisposable {
        private SqlQuery query;

        private Table result;

        private QueryResultColumn[] colDesc;

        private IList<int> rowIndexMap;

        private readonly bool resultIsSimpleEnum;

        private readonly int resultRowCount;

        private int locked;

        private readonly Dictionary<long, StreamableObject> streamableBlobMap;


        public QueryResult(SqlQuery query, Table result) {
            this.query = query;
            this.result = result;
            streamableBlobMap = new Dictionary<long, StreamableObject>();

            resultRowCount = result.RowCount;

            // HACK: Read the contents of the first row so that we can pick up
            //   any errors with reading, and also to fix the 'uniquekey' bug
            //   that causes a new transaction to be started if 'uniquekey' is
            //   a column and the value is resolved later.
            IRowEnumerator rowEnum = result.GetRowEnumerator();
            if (rowEnum.MoveNext()) {
                int rowIndex = rowEnum.RowIndex;
                for (int c = 0; c < result.ColumnCount; ++c) {
                    result.GetCell(c, rowIndex);
                }
            }

            // If simple enum, note it here
            resultIsSimpleEnum = (rowEnum is SimpleRowEnumerator);
            rowEnum = null;

            // Build 'row_index_map' if not a simple enum
            if (!resultIsSimpleEnum) {
                rowIndexMap = new List<int>(result.RowCount);

                IRowEnumerator en = result.GetRowEnumerator();
                while (en.MoveNext()) {
                    rowIndexMap.Add(en.RowIndex);
                }
            }

            // This is a safe operation provides we are shared.
            // Copy all the TableField columns from the table to our own
            // QueryResultColumn array, naming each column by what is returned from
            // the 'GetResolvedVariable' method.
            int colCount = result.ColumnCount;
            colDesc = new QueryResultColumn[colCount];
            for (int i = 0; i < colCount; ++i) {
                VariableName v = result.GetResolvedVariable(i);
                string fieldName;
                if (v.TableName == null) {
                    // This means the column is an alias
                    fieldName = String.Format("@a{0}", v.Name);
                } else {
                    // This means the column is an schema/table/column reference
                    fieldName = String.Format("@f{0}", v);
                }

                colDesc[i] = new QueryResultColumn(fieldName, result.GetColumnInfo(i));
            }

            locked = 0;
        }

        public StreamableObject GetRef(long id) {
            StreamableObject reference;
            if (!streamableBlobMap.TryGetValue(id, out reference))
                return null;

            return reference;
        }

        public void RemoveRef(long id) {
            streamableBlobMap.Remove(id);
        }

        public void Dispose() {
            while (locked > 0) {
                UnlockRoot(-1);
            }
            result = null;
            rowIndexMap = null;
            colDesc = null;
        }

        public TObject GetCellContents(int column, int row) {
            if (locked <= 0)
                throw new Exception("Table roots not locked!");

            int realRow = resultIsSimpleEnum ? row : rowIndexMap[row];
            TObject tob = result.GetCell(column, realRow);

            // If this is a large object reference then cache it so a streamable
            // object can reference it via this result.
            if (tob.Object is IRef) {
                var reference = (IRef) tob.Object;
                streamableBlobMap[reference.Id] = 
                    new StreamableObject(reference.Type, reference.RawSize, reference.Id);
            }

            return tob;
        }

        public int ColumnCount {
            get { return result.ColumnCount; }
        }

        public int RowCount {
            get { return resultRowCount; }
        }

        public QueryResultColumn[] Fields {
            get { return colDesc; }
        }

        public void LockRoot(int key) {
            result.LockRoot(key);
            ++locked;
        }

        private void UnlockRoot(int key) {
            result.UnlockRoot(key);
            --locked;
        }
    }
}