public ICreateTableColumnOptionSyntax PrimaryKey()
{
CurrentColumn.IsPrimaryKey = true;
//For MySQL, the PK will be created WITH the create table expression, however for
// SQL Server, the PK get's created in a different Alter table expression afterwords.
// MySQL will choke if the same constraint is again added afterword
// TODO: This is a super hack, I'd rather not add another property like 'CreatesPkInCreateTableDefinition' to check
// for this, but I don't see another way around. MySQL doesn't support checking for a constraint before creating
// it... except in a very strange way but it doesn't actually provider error feedback if it doesn't work so we cannot use
// it. For now, this is what I'm doing
if (Expression.CurrentDatabaseProvider != DatabaseProviders.MySql)
{
var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, Expression.SqlSyntax, ConstraintType.PrimaryKey)
{
Constraint =
{
TableName = CurrentColumn.TableName,
Columns = new[] { CurrentColumn.Name }
}
};
_context.Expressions.Add(expression);
}
return(this);
}
/// <inheritdoc />
public ICreateConstraintOnTableBuilder PrimaryKey(bool clustered)
{
var expression = new CreateConstraintExpression(_context, ConstraintType.PrimaryKey);
expression.Constraint.IsPrimaryKeyClustered = clustered;
return(new CreateConstraintBuilder(expression));
}
public ICreateConstraintOnTableSyntax UniqueConstraint()
{
var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.Unique);
_context.Expressions.Add(expression);
return(new CreateConstraintBuilder(expression));
}
/// <inheritdoc />
public ICreateConstraintOnTableBuilder Constraint(string constraintName)
{
var expression = new CreateConstraintExpression(_context, ConstraintType.NonUnique);
expression.Constraint.ConstraintName = constraintName;
return(new CreateConstraintBuilder(expression));
}
/// <inheritdoc />
public ICreateConstraintOnTableBuilder PrimaryKey(string primaryKeyName)
{
var expression = new CreateConstraintExpression(_context, ConstraintType.PrimaryKey);
expression.Constraint.ConstraintName = primaryKeyName;
return(new CreateConstraintBuilder(expression));
}
public Constraint.ICreateConstraintOnTableSyntax PrimaryKey()
{
var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
_context.Expressions.Add(expression);
return(new CreateConstraintExpressionBuilder(expression));
}
public ICreateConstraintOnTableSyntax UniqueConstraint()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
_context.Expressions.Add(expression);
return(new CreateConstraintExpressionBuilder(expression));
}
public Constraint.ICreateConstraintOnTableSyntax UniqueConstraint(string constraintName)
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
expression.Constraint.ConstraintName = constraintName;
_context.Expressions.Add(expression);
return(new CreateConstraintExpressionBuilder(expression));
}
/// <inheritdoc />
public ICreateConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
{
var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
expression.Constraint.ConstraintName = primaryKeyName;
_context.Expressions.Add(expression);
return(new CreateConstraintExpressionBuilder(expression));
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
var processed = expression.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.Constraint.SchemaName, Is.Null);
}
public void WhenDefaultSchemaConventionIsChangedAndSchemaIsNotSetThenSetSchema()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.Constraint.SchemaName, Is.EqualTo("testdefault"));
}
public ICreateConstraintOnTableSyntax Constraint(string constraintName)
{
var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.NonUnique);
expression.Constraint.ConstraintName = constraintName;
_context.Expressions.Add(expression);
return(new CreateConstraintBuilder(expression));
}
public ICreateConstraintOnTableSyntax PrimaryKey(string primaryKeyName)
{
var expression = new CreateConstraintExpression(_context.CurrentDatabaseProvider, _databaseProviders, _sqlSyntax, ConstraintType.PrimaryKey);
expression.Constraint.ConstraintName = primaryKeyName;
_context.Expressions.Add(expression);
return(new CreateConstraintBuilder(expression));
}
public static CreateConstraintExpression GetCreateNamedUniqueConstraintExpression()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
expression.Constraint.TableName = TestTableName1;
expression.Constraint.Columns.Add(TestColumnName1);
expression.Constraint.ConstraintName = "TESTUNIQUECONSTRAINT";
return(expression);
}
public static CreateConstraintExpression GetCreateUniqueConstraintExpression()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
expression.Constraint.TableName = TestTableName1;
expression.Constraint.Columns.Add(TestColumnName1);
expression.ApplyConventions(new MigrationConventions());
return(expression);
}
public static CreateConstraintExpression GetCreateNamedPrimaryKeyExpression()
{
var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
expression.Constraint.TableName = TestTableName1;
expression.Constraint.Columns.Add(TestColumnName1);
expression.Constraint.ConstraintName = "TESTPRIMARYKEY";
return(expression);
}
public override string Generate(CreateConstraintExpression expression)
{
var withParts = GetWithOptions(expression);
var withPart = !string.IsNullOrEmpty(withParts)
? $" WITH ({withParts})"
: string.Empty;
return($"{base.Generate(expression)}{withPart}");
}
public static CreateConstraintExpression GetCreateUniqueConstraintExpression()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
expression.Constraint.TableName = TestTableName1;
expression.Constraint.Columns.Add(TestColumnName1);
var processed = expression.Apply(ConventionSets.NoSchemaName);
return(processed);
}
public static CreateConstraintExpression GetCreateMultiColumnPrimaryKeyExpression()
{
var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
expression.Constraint.TableName = TestTableName1;
expression.Constraint.Columns.Add(TestColumnName1);
expression.Constraint.Columns.Add(TestColumnName2);
expression.ApplyConventions(new MigrationConventions());
return(expression);
}
public void CallingColumnsWithDuplicateNamesAddsSetOfColumnNamesForUnique()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
var builder = new CreateConstraintExpressionBuilder(expression);
builder.Columns(new[] { Column1, Column2, Column1 });
Assert.That(expression.Constraint.Columns.Count, Is.EqualTo(2));
}
protected string GetConstraintClusteringString(CreateConstraintExpression constraint)
{
if (!constraint.Constraint.AdditionalFeatures.TryGetValue(
SqlAnywhereExtensions.ConstraintType, out var indexType))
{
return(string.Empty);
}
return((indexType.Equals(SqlAnywhereConstraintType.Clustered)) ? " CLUSTERED" : " NONCLUSTERED");
}
public override void Process(CreateConstraintExpression expression)
{
if (ConstraintExists(expression.Constraint.SchemaName, expression.Constraint.TableName,
expression.Constraint.ConstraintName))
{
return;
}
Process(ExtendedGenerator.Generate(expression));
}
private IEnumerable <MigrationExpressionBase> GetAlters(CreateConstraintExpression from, CreateConstraintExpression to)
{
return(new MigrationExpressionBase[]
{
new DeleteConstraintExpression(ConstraintType.PrimaryKey)
{
Constraint = from.Constraint
},
to
});
}
public override void Process(CreateConstraintExpression expression)
{
expression.ToLower();
if (ConstraintExists(expression.Constraint.SchemaName, expression.Constraint.TableName,
expression.Constraint.ConstraintName))
{
return;
}
base.Process(expression);
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsNotSetThenSchemaShouldBeNull()
{
var expr = new CreateConstraintExpression(ConstraintType.PrimaryKey)
{
Constraint = { ConstraintName = "Test" }
};
var processed = expr.Apply(ConventionSets.NoSchemaName);
Assert.That(processed.Constraint.SchemaName, Is.Null);
}
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique)
{
Constraint = { SchemaName = "testschema" }
};
var processed = expression.Apply(ConventionSets.WithSchemaName);
Assert.That(processed.Constraint.SchemaName, Is.EqualTo("testschema"));
}
protected virtual string GetConstraintClusteringString(CreateConstraintExpression constraint)
{
object indexType;
if (!constraint.Constraint.AdditionalFeatures.TryGetValue(
SqlServerExtensions.ConstraintType, out indexType))
{
return(string.Empty);
}
return(indexType.Equals(SqlServerConstraintType.Clustered) ? " CLUSTERED" : " NONCLUSTERED");
}
public void CanCreatePrimaryKey()
{
var expression = new CreateConstraintExpression(ConstraintType.PrimaryKey);
expression.Constraint.TableName = "ConstraintTable";
expression.Constraint.ConstraintName = "PK_Name";
expression.Constraint.Columns.Add("column1");
string sql = generator.Generate(expression);
sql.ShouldBe("ALTER TABLE \"public\".\"ConstraintTable\" ADD CONSTRAINT \"PK_Name\" PRIMARY KEY (\"column1\")");
}
public void CanCreateUniqueConstraint()
{
var expression = new CreateConstraintExpression(ConstraintType.Unique);
expression.Constraint.TableName = "ConstraintTable";
expression.Constraint.ConstraintName = "Constraint";
expression.Constraint.Columns.Add("column1");
string sql = generator.Generate(expression);
sql.ShouldBe("ALTER TABLE \"public\".\"ConstraintTable\" ADD CONSTRAINT \"Constraint\" UNIQUE (\"column1\")");
}
public override string Generate(CreateConstraintExpression expression)
{
var constraintType = expression.Constraint.IsPrimaryKeyConstraint ? "PRIMARY KEY" : "UNIQUE";
var constraintClustering = GetConstraintClusteringString(expression);
var columns = string.Join(", ", expression.Constraint.Columns.Select(x => Quoter.QuoteColumnName(x)).ToArray());
return(string.Format(CreateConstraint,
Quoter.QuoteTableName(expression.Constraint.TableName, expression.Constraint.SchemaName),
Quoter.Quote(expression.Constraint.ConstraintName),
constraintType,
constraintClustering,
columns));
}
