source: trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact/3.2/DatabaseService.cs @ 2370

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

using HeuristicLab.Core;
using HeuristicLab.DataAnalysis;
using HeuristicLab.Data;
using System.Data.Linq;

namespace HeuristicLab.Modeling.Database.SQLServerCompact {
  public class DatabaseService : IModelingDatabase {

    private readonly string connection;
    public DatabaseService(string connection) {
      this.connection = connection;
      Connect();
      if (!ctx.DatabaseExists())
        ctx.CreateDatabase();
    }

    public void EmptyDatabase() {
      ctx.Connection.Dispose();
      ctx.DeleteDatabase();
      Connect();
      ctx.CreateDatabase();
    }

    private ModelingDataContext ctx;
    public void Connect() {
      if (ctx != null)
        Disconnect();

      ctx = new ModelingDataContext(connection);
      DataLoadOptions dlo = new DataLoadOptions();
      dlo.LoadWith<ModelResult>(mr => mr.Result);
      dlo.LoadWith<ModelMetaData>(mmd => mmd.MetaData);
      dlo.LoadWith<InputVariableResult>(ir => ir.Variable);
      dlo.LoadWith<InputVariableResult>(ir => ir.Result);
      dlo.LoadWith<Model>(m => m.TargetVariable);
      dlo.LoadWith<Model>(m => m.Algorithm);
      ctx.LoadOptions = dlo;
    }

    public void Disconnect() {
      if (ctx == null)
        return;
      ctx.Connection.Dispose();
      ctx.Dispose();
      ctx = null;
    }

    public IModel Persist(HeuristicLab.Modeling.IAlgorithm algorithm) {
      GetOrCreateProblem(algorithm.Dataset);
      return Persist(algorithm.Model, algorithm.Name, algorithm.Description);
    }

    public IModel Persist(HeuristicLab.Modeling.IAnalyzerModel model, string algorithmName, string algorithmDescription) {
      Dictionary<string, Variable> variables = GetAllVariables();
      Algorithm algo = GetOrCreateAlgorithm(algorithmName, algorithmDescription);
      Variable target = variables[model.TargetVariable];
      Model m;

      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        m = new Model(target, algo);
        m.TrainingSamplesStart = model.TrainingSamplesStart;
        m.TrainingSamplesEnd = model.TrainingSamplesEnd;
        m.ValidationSamplesStart = model.ValidationSamplesStart;
        m.ValidationSamplesEnd = model.ValidationSamplesEnd;
        m.TestSamplesStart = model.TestSamplesStart;
        m.TestSamplesEnd = model.TestSamplesEnd;

        ctx.Models.InsertOnSubmit(m);

        ctx.SubmitChanges();
      }

      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        ctx.ModelData.InsertOnSubmit(new ModelData(m, PersistenceManager.SaveToGZip(model.Predictor)));
        ctx.SubmitChanges();
      }

      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        foreach (string inputVariable in model.InputVariables) {
          ctx.InputVariables.InsertOnSubmit(new InputVariable(m, variables[inputVariable]));
        }
        ctx.SubmitChanges();
      }

      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        foreach (KeyValuePair<ModelingResult, double> pair in model.Results) {
          Result result = GetOrCreateResult(pair.Key.ToString());
          ctx.ModelResults.InsertOnSubmit(new ModelResult(m, result, pair.Value));
        }
        ctx.SubmitChanges();
      }

      // code to store meta-information for models (gkronber (8.9.09))
      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        foreach (KeyValuePair<string, double> pair in model.MetaData) {
          MetaData metaData = GetOrCreateMetaData(pair.Key);
          ctx.ModelMetaData.InsertOnSubmit(new ModelMetaData(m, metaData, pair.Value));
        }
        ctx.SubmitChanges();
      }

      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        foreach (InputVariable variable in ctx.InputVariables.Where(iv => iv.Model == m)) {
          foreach (KeyValuePair<ModelingResult, double> variableResult in model.GetVariableResults(variable.Variable.Name)) {
            Result result = GetOrCreateResult(variableResult.Key.ToString());
            ctx.InputVariableResults.InsertOnSubmit(new InputVariableResult(variable, result, variableResult.Value));
          }
        }
        ctx.SubmitChanges();
      }

      //if connected to database return inserted model
      if (this.ctx != null)
        return this.ctx.Models.Where(x => x.Id == m.Id).Single();
      return null;
    }

    #region Problem

    public Dataset GetDataset() {
      if (ctx.Problems.Count() != 1)
        throw new InvalidOperationException("Could not get dataset. No or more than one problems are persisted in the database.");

      Problem problem = ctx.Problems.Single();
      return problem.Dataset;

    }

    public IProblem GetOrCreateProblem(Dataset dataset) {
      IProblem problem;
      if (ctx.Problems.Count() == 0)
        problem = PersistProblem(dataset);
      else
        problem = ctx.Problems.Single();
      if (problem.Dataset.ToString() != dataset.ToString())
        throw new InvalidOperationException("Could not persist dataset. The database already contains a different dataset.");
      return problem;
    }

    public IProblem PersistProblem(Dataset dataset) {
      Problem problem;
      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        if (ctx.Problems.Count() != 0)
          throw new InvalidOperationException("Could not persist dataset. A dataset is already saved in the database.");
        problem = new Problem(dataset);
        ctx.Problems.InsertOnSubmit(problem);
        foreach (string variable in dataset.VariableNames) {
          ctx.Variables.InsertOnSubmit(new Variable(variable));
        }
        ctx.SubmitChanges();
      }
      return problem;
    }

    #endregion

    #region Algorithm
    public Algorithm GetOrCreateAlgorithm(string name, string description) {
      Algorithm algorithm;
      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        var algorithms = from algo in ctx.Algorithms
                         where algo.Name == name && algo.Description == description
                         select algo;
        if (algorithms.Count() == 0) {
          algorithm = new Algorithm(name, description);
          ctx.Algorithms.InsertOnSubmit(algorithm);
          ctx.SubmitChanges();
        } else if (algorithms.Count() == 1)
          algorithm = algorithms.Single();
        else
          throw new ArgumentException("Could not get Algorithm. More than one algorithm with the name " + name + " are saved in database.");
      }
      return algorithm;
    }

    public IEnumerable<IAlgorithm> GetAllAlgorithms() {
      return ctx.Algorithms.ToList().Cast<IAlgorithm>();
    }
    #endregion

    #region Variables
    public Dictionary<string, Variable> GetAllVariables() {
      Dictionary<string, Variable> dict = new Dictionary<string, Variable>();
      dict = ctx.Variables.ToDictionary<Variable, string>(delegate(Variable v) { return v.Name; });
      return dict;
    }
    #endregion

    #region Result
    public Result GetOrCreateResult(string name) {
      Result result;
      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        var results = from r in ctx.Results
                      where r.Name == name
                      select r;
        if (results.Count() == 0) {
          result = new Result(name);
          ctx.Results.InsertOnSubmit(result);
          ctx.SubmitChanges();
        } else if (results.Count() == 1)
          result = results.Single();
        else
          throw new ArgumentException("Could not get result. More than one result with the name " + name + " are saved in database.");
      }
      return result;
    }

    public IEnumerable<IResult> GetAllResults() {
      return ctx.Results.ToList().Cast<IResult>();
    }

    public IEnumerable<IResult> GetAllResultsForInputVariables() {
      return (from ir in ctx.InputVariableResults select ir.Result).Distinct().ToList().Cast<IResult>();
    }

    #endregion

    #region ModelResult
    public IEnumerable<IModelResult> GetModelResults(IModel model) {
      var results = from result in ctx.ModelResults
                    where result.Model == model
                    select result;
      return results.ToList().Cast<IModelResult>();
    }
    #endregion

    #region InputVariableResults
    public IEnumerable<IInputVariableResult> GetInputVariableResults(IModel model) {
      var inputResults = from ir in ctx.InputVariableResults
                         where ir.Model == model
                         select ir;
      return inputResults.ToList().Cast<IInputVariableResult>();
    }

    #endregion

    #region ModelMetaData
    public IEnumerable<IModelMetaData> GetModelMetaData(IModel model) {
      var metadata = from md in ctx.ModelMetaData
                     where md.Model == model
                     select md;
      return metadata.ToList().Cast<IModelMetaData>();
    }
    #endregion

    #region MetaData
    public IEnumerable<IMetaData> GetAllMetaData() {
      return ctx.MetaData.ToList().Cast<IMetaData>();
    }

    public MetaData GetOrCreateMetaData(string name) {
      MetaData metadata;
      using (ModelingDataContext ctx = new ModelingDataContext(connection)) {
        var md = from r in ctx.MetaData
                 where r.Name == name
                 select r;
        if (md.Count() == 0) {
          metadata = new MetaData(name);
          ctx.MetaData.InsertOnSubmit(metadata);
          ctx.SubmitChanges();
        } else if (md.Count() == 1)
          metadata = md.Single();
        else
          throw new ArgumentException("Could not get metadata. More than one metadata with the name " + name + " are saved in database.");
      }
      return metadata;
    }

    #endregion

    #region Model
    public IEnumerable<IModel> GetAllModels() {
      return ctx.Models.ToList().Cast<IModel>();
    }

    public void UpdateModel(IModel model) {
      Model m = (Model)model;
      Model orginal = ctx.Models.GetOriginalEntityState(m);
      if (orginal == null)
        ctx.Models.Attach(m);
      ctx.Refresh(RefreshMode.KeepCurrentValues, m);
      ctx.SubmitChanges();
    }

    public byte[] GetModelData(IModel model) {
      var data = (from md in ctx.ModelData
                  where md.Model == model
                  select md);
      if (data.Count() == 0)
        return null;
      return data.Single().Data;
    }

    public void UpdateModelData(IModel model, byte[] modelData) {
      Model m = (Model)model;
      ctx.ModelData.DeleteAllOnSubmit(ctx.ModelData.Where(x => x.Model == m));
      ctx.ModelData.InsertOnSubmit(new ModelData(m, modelData));
      ctx.SubmitChanges();
    }

    public IPredictor GetModelPredictor(IModel model) {
      byte[] data = GetModelData(model);
      return (IPredictor)PersistenceManager.RestoreFromGZip(data);
    }
    #endregion
  }
}