public void DefaultedSequenceBackedConfiguration()
        {
            var dialect   = new SequenceDialect();
            var props     = new Dictionary <string, string>();
            var generator = new SequenceStyleGenerator();

            generator.Configure(NHibernateUtil.Int64, props, dialect);

            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.NoopOptimizer)));
            Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
        }
Example #2
0
        public void ForceTableUse()
        {
            Dialect.Dialect dialect            = new SequenceDialect();
            IDictionary <string, string> props = new Dictionary <string, string>();

            props[SequenceStyleGenerator.ForceTableParam] = "true";
            SequenceStyleGenerator generator = new SequenceStyleGenerator();

            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(TableStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.NoopOptimizer)));
            Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
        }
        public void ExplicitOptimizerWithExplicitIncrementSize()
        {
            var dialect = new SequenceDialect();

            // optimizer=none w/ increment > 1 => should honor optimizer
            var props = new Dictionary <string, string>();

            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.None;
            props[SequenceStyleGenerator.IncrementParam] = "20";

            var generator = new SequenceStyleGenerator();

            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.NoopOptimizer)));
            Assert.That(generator.Optimizer.IncrementSize, Is.EqualTo(1));
            Assert.That(generator.DatabaseStructure.IncrementSize, Is.EqualTo(1));

            // optimizer=hilo w/ increment > 1 => hilo
            props = new Dictionary <string, string>();
            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.HiLo;
            props[SequenceStyleGenerator.IncrementParam] = "20";
            generator = new SequenceStyleGenerator();
            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.HiLoOptimizer)));
            Assert.That(generator.Optimizer.IncrementSize, Is.EqualTo(20));
            Assert.That(generator.DatabaseStructure.IncrementSize, Is.EqualTo(20));

            // optimizer=pooled w/ increment > 1 => pooled+table
            props = new Dictionary <string, string>();
            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.Pool;
            props[SequenceStyleGenerator.IncrementParam] = "20";
            generator = new SequenceStyleGenerator();
            generator.Configure(NHibernateUtil.Int64, props, dialect);
            // because the dialect reports that it does not support pooled sequences, the expectation is that we will
            // use a table for the backing structure...
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(TableStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.PooledOptimizer)));
            Assert.That(generator.Optimizer.IncrementSize, Is.EqualTo(20));
            Assert.That(generator.DatabaseStructure.IncrementSize, Is.EqualTo(20));
        }
		public void ExplicitOptimizerWithExplicitIncrementSize()
		{
			// with sequence ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			Dialect.Dialect dialect = new SequenceDialect();

			// optimizer=none w/ increment > 1 => should honor optimizer
			IDictionary<string, string> props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.None;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			SequenceStyleGenerator generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.NoopOptimizer)));
			Assert.AreEqual(1, generator.Optimizer.IncrementSize);
			Assert.AreEqual(1, generator.DatabaseStructure.IncrementSize);

			// optimizer=hilo w/ increment > 1 => hilo
			props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.HiLo;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.HiLoOptimizer)));
			Assert.AreEqual(20, generator.Optimizer.IncrementSize);
			Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);

			// optimizer=pooled w/ increment > 1 => pooled+table
			props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.Pool;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			// because the dialect reports that it does not support pooled sequences, the expectation is that we will
			// use a table for the backing structure...
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (TableStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.PooledOptimizer)));
			Assert.AreEqual(20, generator.Optimizer.IncrementSize);
			Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);
		}
Example #5
0
        public void ExplicitOptimizerWithExplicitIncrementSize()
        {
            // with sequence ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            Dialect.Dialect dialect = new SequenceDialect();

            // optimizer=none w/ increment > 1 => should honor optimizer
            IDictionary <string, string> props = new Dictionary <string, string>();

            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.None;
            props[SequenceStyleGenerator.IncrementParam] = "20";
            SequenceStyleGenerator generator = new SequenceStyleGenerator();

            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.NoopOptimizer)));
            Assert.AreEqual(1, generator.Optimizer.IncrementSize);
            Assert.AreEqual(1, generator.DatabaseStructure.IncrementSize);

            // optimizer=hilo w/ increment > 1 => hilo
            props = new Dictionary <string, string>();
            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.HiLo;
            props[SequenceStyleGenerator.IncrementParam] = "20";
            generator = new SequenceStyleGenerator();
            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.HiLoOptimizer)));
            Assert.AreEqual(20, generator.Optimizer.IncrementSize);
            Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);

            // optimizer=pooled w/ increment > 1 => hilo
            props = new Dictionary <string, string>();
            props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.Pool;
            props[SequenceStyleGenerator.IncrementParam] = "20";
            generator = new SequenceStyleGenerator();
            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.HiLoOptimizer)));
            Assert.AreEqual(20, generator.Optimizer.IncrementSize);
            Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);
        }
		public void ExplicitOptimizerWithExplicitIncrementSize()
		{
			// with sequence ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
			Dialect.Dialect dialect = new SequenceDialect();

			// optimizer=none w/ increment > 1 => should honor optimizer
			IDictionary<string, string> props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.None;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			SequenceStyleGenerator generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.NoopOptimizer)));
			Assert.AreEqual(1, generator.Optimizer.IncrementSize);
			Assert.AreEqual(1, generator.DatabaseStructure.IncrementSize);

			// optimizer=hilo w/ increment > 1 => hilo
			props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.HiLo;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.HiLoOptimizer)));
			Assert.AreEqual(20, generator.Optimizer.IncrementSize);
			Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);

			// optimizer=pooled w/ increment > 1 => hilo
			props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.OptimizerParam] = OptimizerFactory.Pool;
			props[SequenceStyleGenerator.IncrementParam] = "20";
			generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.HiLoOptimizer)));
			Assert.AreEqual(20, generator.Optimizer.IncrementSize);
			Assert.AreEqual(20, generator.DatabaseStructure.IncrementSize);
		}
        public void DefaultOptimizerBasedOnIncrementBackedBySequence()
        {
            var props = new Dictionary <string, string>();

            props[SequenceStyleGenerator.IncrementParam] = "10";

            // for dialects which do not support pooled sequences, we default to pooled+table
            var dialect   = new SequenceDialect();
            var generator = new SequenceStyleGenerator();

            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(TableStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.PooledOptimizer)));
            Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));

            // for dialects which do support pooled sequences, we default to pooled+sequence
            dialect   = new PooledSequenceDialect();
            generator = new SequenceStyleGenerator();
            generator.Configure(NHibernateUtil.Int64, props, dialect);
            Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof(SequenceStructure)));
            Assert.That(generator.Optimizer, Is.AssignableFrom(typeof(OptimizerFactory.PooledOptimizer)));
            Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
        }
		public void DefaultedSequenceBackedConfiguration()
		{
			Dialect.Dialect dialect = new SequenceDialect();
			IDictionary<string, string> props = new Dictionary<string, string>();
			SequenceStyleGenerator generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);

			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.NoopOptimizer)));
			Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
		}
		public void DefaultOptimizerBasedOnIncrementBackedBySequence()
		{
			IDictionary<string, string> props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.IncrementParam] = "10";

			// for dialects which do not support pooled sequences, we default to hilo
			Dialect.Dialect dialect = new SequenceDialect();
			SequenceStyleGenerator generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.HiLoOptimizer)));
			Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));

			// for dialects which do support pooled sequences, we default to pooled
			dialect = new PooledSequenceDialect();
			generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (SequenceStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.PooledOptimizer)));
			Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
		}
		public void ForceTableUse()
		{
			var dialect = new SequenceDialect();
			var props = new Dictionary<string, string>();
			props[SequenceStyleGenerator.ForceTableParam] = "true";
			var generator = new SequenceStyleGenerator();
			generator.Configure(NHibernateUtil.Int64, props, dialect);
			Assert.That(generator.DatabaseStructure, Is.AssignableFrom(typeof (TableStructure)));
			Assert.That(generator.Optimizer, Is.AssignableFrom(typeof (OptimizerFactory.NoopOptimizer)));
			Assert.That(generator.DatabaseStructure.Name, Is.EqualTo(SequenceStyleGenerator.DefaultSequenceName));
		}