Changeset 2530 for trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact

Timestamp:

11/24/09 15:15:16 (15 years ago)

Author:

mkommend

Message:

changed modeling database backend to use a shared read connection => notification by exception if another program is connected to the database (ticket #759)

Location:

trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact/3.2

Files:

• DatabaseService.cs (modified) (20 diffs)
• PredictorPersister.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact/3.2/DatabaseService.cs

@@ -87 +87 @@
       dlo.LoadWith<Model>(m => m.Algorithm);
       ctx.LoadOptions = dlo;
-
-      if (!ctx.DatabaseExists())
+      //ctx.Log = System.Console.Out;
+
+      if (!ctx.DatabaseExists() && !this.ReadOnly)
         ctx.CreateDatabase();
     }
@@ -100 +101 @@
     }
 
+    public void Commit() {
+      if (ctx != null)
+        ctx.SubmitChanges();
+    }
+
+    private void CheckConnection() {
+      CheckConnection(false);
+    }
+
+    private void CheckConnection(bool writeEnabled) {
+      if (ctx == null)
+        throw new InvalidOperationException("Could not perform operation, when not connected to the database.");
+      if (writeEnabled && this.ReadOnly)
+        throw new InvalidOperationException("Could not perform update operation, when database is in readonly mode.");
+    }
+
     public IEnumerable<IModel> GetAllModels() {
+      this.CheckConnection();
       return ctx.Models.ToList().Cast<IModel>();
     }
 
     public IEnumerable<int> GetAllModelIds() {
+      this.CheckConnection();
       return from m in ctx.Models
              select m.Id;
@@ -110 +129 @@
 
     public IEnumerable<IVariable> GetAllVariables() {
+      this.CheckConnection();
       return ctx.Variables.ToList().Cast<IVariable>();
     }
 
     public IEnumerable<IResult> GetAllResults() {
+      this.CheckConnection();
       return ctx.Results.ToList().Cast<IResult>();
     }
 
     public IEnumerable<IResult> GetAllResultsForInputVariables() {
+      this.CheckConnection();
       return (from ir in ctx.InputVariableResults select ir.Result).Distinct().ToList().Cast<IResult>();
     }
 
     public IEnumerable<IMetaData> GetAllMetaData() {
+      this.CheckConnection();
       return ctx.MetaData.ToList().Cast<IMetaData>();
     }
 
     public IEnumerable<IAlgorithm> GetAllAlgorithms() {
+      this.CheckConnection();
       return ctx.Algorithms.ToList().Cast<IAlgorithm>();
     }
@@ -153 +177 @@
 
     public IModel GetModel(int id) {
+      this.CheckConnection();
       var model = ctx.Models.Where(m => m.Id == id);
       if (model.Count() == 1)
@@ -160 +185 @@
 
     public void PersistModel(IModel model) {
+      this.CheckConnection(true);
       Model m = (Model)model;
       //check if model has to be updated or inserted
@@ -169 +195 @@
       } else
         ctx.Models.InsertOnSubmit(m);
-      ctx.SubmitChanges();
     }
 
     public void DeleteModel(IModel model) {
+      this.CheckConnection(true);
       Model m = (Model)model;
       ctx.ModelData.DeleteAllOnSubmit(ctx.ModelData.Where(x => x.Model == m));
@@ -187 +213 @@
 
     public Dataset GetDataset() {
+      this.CheckConnection();
       if (ctx.Problems.Count() > 1)
         throw new InvalidOperationException("Could not get dataset. More than one problems are persisted in the database.");
@@ -195 +222 @@
 
     public void PersistProblem(Dataset dataset) {
+      this.CheckConnection(true);
       Problem problem;
       if (ctx.Problems.Count() != 0)
@@ -203 +231 @@
         ctx.Variables.InsertOnSubmit(new Variable(variable));
       }
-      ctx.SubmitChanges();
     }
 
     public IVariable GetVariable(string variableName) {
+      this.CheckConnection();
       var variables = ctx.Variables.Where(v => v.Name == variableName);
       if (variables.Count() != 1)
@@ -214 +242 @@
 
     public IPredictor GetModelPredictor(IModel model) {
+      this.CheckConnection();
       var data = (from md in ctx.ModelData
                   where md.Model == model
@@ -223 +252 @@
 
     public void PersistPredictor(IModel model, IPredictor predictor) {
+      this.CheckConnection(true);
       Model m = (Model)model;
       ctx.ModelData.DeleteAllOnSubmit(ctx.ModelData.Where(x => x.Model == m));
@@ -232 +262 @@
       foreach (string variableName in predictor.GetInputVariables())
         ctx.InputVariables.InsertOnSubmit(new InputVariable(m, (Variable)GetVariable(variableName)));
-
-      ctx.SubmitChanges();
     }
 
     public IInputVariable GetInputVariable(IModel model, string inputVariableName) {
+      this.CheckConnection();
       var inputVariables = ctx.InputVariables.Where(i => i.Model == model && i.Variable.Name == inputVariableName);
       if (inputVariables.Count() == 1)
@@ -248 +277 @@
 
     public IAlgorithm GetOrPersistAlgorithm(string algorithmName) {
+      this.CheckConnection();
       Algorithm algorithm;
       var algorithms = ctx.Algorithms.Where(algo => algo.Name == algorithmName);
       if (algorithms.Count() == 0) {
         algorithm = new Algorithm(algorithmName, "");
+        this.CheckConnection(true);
         ctx.Algorithms.InsertOnSubmit(algorithm);
         ctx.SubmitChanges();
@@ -262 +293 @@
 
     public IResult GetOrPersistResult(string resultName) {
+      this.CheckConnection();
       Result result;
       var results = ctx.Results.Where(r => r.Name == resultName);
       if (results.Count() == 0) {
+        this.CheckConnection(true);
         result = new Result(resultName);
         ctx.Results.InsertOnSubmit(result);
@@ -276 +309 @@
 
     public IMetaData GetOrPersistMetaData(string metaDataName) {
+      this.CheckConnection();
       MetaData metadata;
       var md = ctx.MetaData.Where(r => r.Name == metaDataName);
       if (md.Count() == 0) {
+        this.CheckConnection(true);
         metadata = new MetaData(metaDataName);
         ctx.MetaData.InsertOnSubmit(metadata);
@@ -290 +325 @@
 
     public IEnumerable<IModelResult> GetModelResults(IModel model) {
+      this.CheckConnection();
       return ctx.ModelResults.Where(mr => mr.Model == model).Cast<IModelResult>();
     }
     public IEnumerable<IInputVariableResult> GetInputVariableResults(IModel model) {
+      this.CheckConnection();
       return ctx.InputVariableResults.Where(ivr => ivr.Model == model).Cast<IInputVariableResult>();
     }
     public IEnumerable<IModelMetaData> GetModelMetaData(IModel model) {
+      this.CheckConnection();
       return ctx.ModelMetaData.Where(md => md.Model == model).Cast<IModelMetaData>();
     }
@@ -306 +344 @@
 
     public void PersistModelResults(IModel model, IEnumerable<IModelResult> modelResults) {
+      this.CheckConnection(true);
       ctx.ModelResults.DeleteAllOnSubmit(GetModelResults(model).Cast<ModelResult>());
       ctx.ModelResults.InsertAllOnSubmit(modelResults.Cast<ModelResult>());
-      ctx.SubmitChanges();
     }
 
@@ -323 +361 @@
 
     public void PersistInputVariableResults(IModel model, IEnumerable<IInputVariableResult> inputVariableResults) {
+      this.CheckConnection(true);
       ctx.InputVariableResults.DeleteAllOnSubmit(GetInputVariableResults(model).Cast<InputVariableResult>());
       ctx.InputVariableResults.InsertAllOnSubmit(inputVariableResults.Cast<InputVariableResult>());
-      ctx.SubmitChanges();
     }
 
@@ -335 +373 @@
 
     public void PersistModelMetaData(IModel model, IEnumerable<IModelMetaData> modelMetaData) {
+      this.CheckConnection(true);
       ctx.ModelMetaData.DeleteAllOnSubmit(GetModelMetaData(model).Cast<ModelMetaData>());
       ctx.ModelMetaData.InsertAllOnSubmit(modelMetaData.Cast<ModelMetaData>());
-      ctx.SubmitChanges();
-    }
-
-    public IModel Persist(HeuristicLab.Modeling.IAlgorithm algorithm) {
-      if (ctx.Problems.Count() == 0)
-        PersistProblem(algorithm.Dataset);
-      return Persist(algorithm.Model, algorithm.Name, algorithm.Description);
-    }
-
-    public IModel Persist(HeuristicLab.Modeling.IAnalyzerModel model, string algorithmName, string algorithmDescription) {
+    }
+
+    public void Persist(HeuristicLab.Modeling.IAnalyzerModel model, string algorithmName, string algorithmDescription) {
+      this.CheckConnection(true);
       Algorithm algorithm = (Algorithm)GetOrPersistAlgorithm(algorithmName);
-      Variable targetVariable = (Variable) GetVariable(model.TargetVariable);
+      Variable targetVariable = (Variable)GetVariable(model.TargetVariable);
       Model m = (Model)CreateModel(null, model.Type, algorithm, targetVariable, model.TrainingSamplesStart, model.TrainingSamplesEnd,
         model.ValidationSamplesStart, model.ValidationSamplesEnd, model.TestSamplesStart, model.TestSamplesEnd);
       ctx.Models.InsertOnSubmit(m);
       ctx.SubmitChanges();
-      ctx.ModelData.InsertOnSubmit(new ModelData(m, PersistenceManager.SaveToGZip(model.Predictor)));
+      ctx.ModelData.InsertOnSubmit(new ModelData(m, PersistenceManager.SaveToGZip(model.Predictor)));      
 
       foreach (string variableName in model.Predictor.GetInputVariables())
@@ -374 +407 @@
         }
       }
-      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;
+     ctx.SubmitChanges();
     }
   }

trunk/sources/HeuristicLab.Modeling.Database.SQLServerCompact/3.2/PredictorPersister.cs

@@ -38 +38 @@
       db.Connect();
       Dataset temp = db.GetDataset();
-      if(temp == null)      
-        db.PersistProblem(ds);      
+      if (temp == null) {
+        db.PersistProblem(ds);
+        db.Commit();
+      }
 
       IAnalyzerModel model = new AnalyzerModel();                 
       DefaultModelAnalyzerOperators.PopulateAnalyzerModel(scope, model, modelType);
       db.Persist(model, algorithm, algorithm);
+      db.Commit();
       db.Disconnect();