Database.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 Deveel.Data.Diagnostics;
using Deveel.Data.Security;
using Deveel.Data.Sql;
using Deveel.Data.Sql.Schemas;
using Deveel.Data.Sql.Tables;
using Deveel.Data.Transactions;

namespace Deveel.Data {
    public sealed class Database : IDatabase {
        internal Database(DatabaseSystem system, IDatabaseContext context) {
            System = system;
            Context = context;

            Name = Context.DatabaseName();

            DiscoverDataVersion();

            TableComposite = new TableSourceComposite(this);

            Context.RegisterInstance(this);
            Context.RegisterInstance<ITableSourceComposite>(TableComposite);

            Locker = new Locker(this);

            Sessions = new ActiveSessionList(this);

            // Create the single row table
            var t = new TemporaryTable(context, "SINGLE_ROW_TABLE", new ColumnInfo[0]);
            t.NewRow();
            SingleRowTable = t;

            TransactionFactory = new DatabaseTransactionFactory(this);
        }

        ~Database() {
            Dispose(false);
        }

        public string Name { get; private set; }

        public DatabaseSystem System { get; private set; }

        public ActiveSessionList Sessions { get; private set; }

        public Locker Locker { get; private set; }

        public ITransactionFactory TransactionFactory { get; private set; }

        IEventSource IEventSource.ParentSource {
            get { return System; }
        }

        IContext IEventSource.Context {
            get { return Context; }
        }

        IEnumerable<KeyValuePair<string, object>> IEventSource.Metadata {
            get {
                return new Dictionary<string, object> {
                    { KnownEventMetadata.DatabaseName, Name },
                    { KnownEventMetadata.SessionCount, Sessions.Count }
                };
            }
        }

        private void DiscoverDataVersion() {
            var dataVerion = Attribute.GetCustomAttribute(typeof (Database).Assembly, typeof (DataVersionAttribute))
                as DataVersionAttribute;
            if (dataVerion != null)
                Version = dataVerion.Version;
        }

        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private bool disposed;

        private void Dispose(bool disposing) {
            if (!disposed) {
                if (disposing) {
                    if (IsOpen) {
                        // TODO: Report the error
                    }

                    if (Locker != null)
                        Locker.Reset();

                    if (TableComposite != null)
                        TableComposite.Dispose();

                    if (Context != null)
                        Context.Dispose();

                    if (System != null)
                        System.RemoveDatabase(this);
                }

                Locker = null;
                System = null;
                TableComposite = null;
                Context = null;
                disposed = true;
            }
        }

        public IDatabaseContext Context { get; private set; }

        public Version Version { get; private set; }

        public bool Exists {
            get {
                if (IsOpen)
                    //throw new Exception("The database is initialized, so no point testing it's existence.");
                    return true;

                try {
                    return TableComposite.Exists();
                } catch (IOException e) {
                    throw new Exception("An error occurred while testing database existence.", e);
                }
            }
        }

        public bool IsOpen { get; private set; }

        internal TableSourceComposite TableComposite { get; private set; }

        public ITable SingleRowTable { get; private set; }

        private void OnDatabaseCreate(IQuery context) {
            var callbacks = Context.ResolveAllServices<IDatabaseCreateCallback>();
            if (callbacks != null) {
                foreach (var callback in callbacks) {
                    try {
                        if (callback != null)
                            callback.OnDatabaseCreate(context);
                    } catch (Exception) {
                        //TODO: Route an error event to the listeners
                    }
                }
            }
        }

        public void Create(string adminName, string adminPassword) {
            if (Context.ReadOnly())
                throw new DatabaseSystemException("Cannot create database in read-only mode.");

            if (String.IsNullOrEmpty(adminName))
                throw new ArgumentNullException("adminName");
            if (String.IsNullOrEmpty(adminPassword))
                throw new ArgumentNullException("adminPassword");

            try {
                // Create the conglomerate
                TableComposite.Create();

                using (var session = this.CreateInitialSystemSession()) {
                    using (var context = session.CreateQuery()) {
                        try {
                            session.CurrentSchema(SystemSchema.Name);

                            // Create the schema information tables
                            CreateSchemata(context);

                            // The system tables that are present in every conglomerate.
                            SystemSchema.CreateTables(context);
                            SystemGroups.Create(context);

                            context.CreatePublicUser();

                            // Create the system views
                            InformationSchema.CreateViews(context);
                            InformationSchema.GrantToPublic(context);

                            this.CreateAdminUser(context, adminName, adminPassword);

                            SetCurrentDataVersion(context);

                            // Set all default system procedures.
                            // TODO: SystemSchema.SetupSystemFunctions(session, username);

                            OnDatabaseCreate(context);

                            try {
                                // Close and commit this transaction.
                                session.Commit();
                            } catch (TransactionException e) {
                                throw new DatabaseSystemException("Could not commit the initial information", e);
                            }
                        } catch (DatabaseSystemException) {
                            throw;
                        } catch (Exception ex) {
                            throw new DatabaseSystemException("An error occurred while creating the database.", ex);
                        }
                    }
                }

                // Close the conglomerate.
                TableComposite.Close();
            } catch (DatabaseSystemException) {
                throw;
            } catch (Exception e) {
                throw new DatabaseSystemException("An error occurred while creating the database.", e);
            }
        }

        private void SetCurrentDataVersion(IQuery context) {
            // TODO: Get the data version and then set it to the database table 'vars'
        }

        private void CreateSchemata(IQuery context) {
            try {
                context.CreateSchema(InformationSchema.SchemaName, SchemaTypes.System);
                context.CreateSchema(Context.DefaultSchema(), SchemaTypes.Default);
            } catch (DatabaseSystemException) {
                throw;
            } catch (Exception ex) {
                throw new DatabaseSystemException("Unable to create the default schema for the database.", ex);
            }
        }

        public void Open() {
            if (IsOpen)
                throw new DatabaseSystemException("The database was already initialized.");

            try {
                // Check if the state file exists.  If it doesn't, we need to report
                // incorrect version.
                if (!TableComposite.Exists())
                    // If neither store or state file exist, assume database doesn't
                    // exist.
                    throw new DatabaseSystemException(String.Format("The database {0} does not exist.", Name));

                // Open the conglomerate
                TableComposite.Open();

                AssertDataVersion();
            } catch (DatabaseSystemException) {
                throw;
            } catch (Exception e) {
                throw new DatabaseSystemException("An error occurred when initializing the database.", e);
            }

            IsOpen = true;
        }

        private void AssertDataVersion() {
            // TODO:
        }

        public void Close() {
            if (!IsOpen)
                throw new DatabaseSystemException("The database is not initialized.");

            try {
                if (Context.DeleteOnClose()) {
                    // Delete the tables if the database is set to delete on
                    // shutdown.
                    TableComposite.Delete();
                } else {
                    // Otherwise close the conglomerate.
                    TableComposite.Close();
                }
            } catch (DatabaseSystemException) {
                throw;
            } catch (Exception e) {
                throw new DatabaseSystemException("An error occurred during database shutdown.", e);
            } finally {
                IsOpen = false;
            }
        }

        #region DatabaseTransactionFactory

        class DatabaseTransactionFactory : ITransactionFactory {
            private readonly Database database;

            public DatabaseTransactionFactory(Database database) {
                this.database = database;
                OpenTransactions = new TransactionCollection();
            }

            public TransactionCollection OpenTransactions { get; private set; }

            public ITransaction CreateTransaction(IsolationLevel isolation) {
                lock (this) {
                    ITransaction transaction;

                    try {
                        transaction = database.TableComposite.CreateTransaction(isolation);
                    } catch (DatabaseSystemException) {
                        throw;
                    } catch (Exception ex) {
                        throw new DatabaseSystemException("Unable to create a transaction.", ex);
                    }

                    return transaction;
                }
            }
        }

        #endregion
    }
}