public void ErrorIsReturnedWhenTableNameIsNull()
        {
            var expression = new DeleteIndexExpression { Index = { Name = "IX", TableName = null } };

            var errors = ValidationHelper.CollectErrors(expression);
            errors.ShouldContain(ErrorMessages.TableNameCannotBeNullOrEmpty);
        }

        public void ErrorIsNotReturnedWhenIndexNameAndTableNameAreSet()
        {
            var expression = new DeleteIndexExpression { Index = { Name = "IX", TableName = "test" } };

            var errors = ValidationHelper.CollectErrors(expression);
            Assert.That(errors.Count, Is.EqualTo(0));
        }

 public IDeleteIndexForTableSyntax Index(string indexName)
 {
     var expression = new DeleteIndexExpression();
     expression.Index.Name = indexName;
     _context.Expressions.Add(expression);
     return new DeleteIndexExpressionBuilder(expression);
 }

        public void ShouldDelegateApplyConventionsToIndexDefinition()
        {
            var definitionMock = new Mock<IndexDefinition>();
            var createIndexExpression = new DeleteIndexExpression {Index = definitionMock.Object};
            var migrationConventions = new Mock<IMigrationConventions>(MockBehavior.Strict).Object;

            definitionMock.Setup(id => id.ApplyConventions(migrationConventions)).Verifiable();

            createIndexExpression.ApplyConventions(migrationConventions);

            definitionMock.VerifyAll();
        }

 public override string Generate(DeleteIndexExpression expression)
 {
     throw new NotImplementedException();
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     return string.Format("DROP INDEX {0}.{1}", Quoter.QuoteSchemaName(expression.Index.SchemaName), Quoter.QuoteIndexName(expression.Index.Name));
 }

 public virtual void Process(DeleteIndexExpression expression)
 {
     Process(Generator.Generate(expression));
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     return string.Format("DROP INDEX {0}.{1}", FormatSchema(expression.Index.SchemaName), FormatIdentifier(expression.Index.Name));
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     return String.Format(DropIndex, Quoter.QuoteIndexName(expression.Index.Name), Quoter.QuoteTableName(expression.Index.TableName));
 }

 public void Truncate(DeleteIndexExpression expression)
 {
     Truncate(expression.Index);
 }

        public void CanDropIndex()
        {
            var expression = new DeleteIndexExpression();
            expression.Index.Name = "IX_TEST";
            expression.Index.TableName = "TEST_TABLE";

            string sql = generator.Generate(expression);
            sql.ShouldBe("DROP INDEX \"public\".\"IX_TEST\"");
        }

 public abstract string Generate(DeleteIndexExpression expression);

 public override string Generate(DeleteIndexExpression expression)
 {
     return String.Format(DropIndex, Quoter.QuoteIndexName(expression.Index.Name), CommandDelimiter);
 }

        public void CanDeleteIndex()
        {
            var expression = new DeleteIndexExpression();
            expression.Index.Name = "IX_TEST";
            expression.Index.TableName = "TEST_TABLE";

            var sql = generator.Generate(expression);
            sql.ShouldBe("DROP INDEX IX_TEST ON [TEST_TABLE]");
        }

        public void CanCreateAndDropIndex()
        {
            _processor.Process(new CreateTableExpression
             {
            TableName = "Foo",
            Columns = { new ColumnDefinition { Name = "Bar", Type = DbType.Decimal } }
             });

             var index = new CreateIndexExpression
                        {
                           Index = new IndexDefinition
                                      {
                                         TableName = "Foo"
                                         ,Name = "IDX_Bar"
                                         ,Columns = new[] {new IndexColumnDefinition {Name = "Bar"}}
                                      }
                        };
             _processor.Process(index);

             var dropIndex = new DeleteIndexExpression
                            {
                              Index = new IndexDefinition
                                         {
                                            TableName = "Foo"
                                            ,Name = "IDX_Bar"
                                         }
                           };

             _processor.Process(dropIndex);
        }

 public override string Generate(DeleteIndexExpression expression)
 {
     return String.Format("DROP INDEX {0}[{1}] ON [{2}]", FormatSchema(expression.Index.SchemaName), expression.Index.Name, expression.Index.TableName);
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     return String.Format("DROP INDEX {0}", expression.Index.Name, expression.Index.TableName);
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     truncator.Truncate(expression);
     return base.Generate(expression);
 }

 public override string Generate(DeleteIndexExpression expression)
 {
     return string.Format("{0};", base.Generate(expression));
 }