public TableConstraint(
string identifier,
DatabaseKeyType keyType,
string constraintName,
IEnumerable <string> columnNames,
IEnumerable <string> columnTypes
)
{
if (identifier.IsNullOrWhiteSpace())
{
throw new ArgumentNullException(nameof(identifier));
}
Identifier = identifier;
if (!keyType.IsValid())
{
throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType));
}
KeyTitle = _keyTypeTitles[keyType];
KeyType = keyType;
ConstraintName = constraintName ?? string.Empty;
ColumnNames = columnNames?.ToList() ?? throw new ArgumentNullException(nameof(columnNames));
ColumnTypes = columnTypes?.ToList() ?? throw new ArgumentNullException(nameof(columnTypes));
}
public static void Ctor_GivenNullColumnSet_ThrowsArgumentNullException()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, null), Throws.ArgumentNullException);
}
public static void Ctor_GivenNullName_DoesNotThrowArgumentNullException()
{
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
Assert.That(() => new DatabaseKey(null, keyType, columns, true), Throws.Nothing);
}
public static void Ctor_GivenInvalidKeyType_ThrowsArgumentException()
{
const DatabaseKeyType badKeyType = (DatabaseKeyType)55;
Assert.That(() => new FakeKey(new List <IModelledColumn> {
Mock.Of <IModelledColumn>()
}, badKeyType), Throws.ArgumentException);
}
public static void Ctor_GivenEmptyColumnSet_ThrowsArgumentNullException()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var columns = Array.Empty <IDatabaseColumn>();
Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentNullException);
}
public static void Ctor_GivenColumnSetContainingNullColumn_ThrowsArgumentNullException()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var columns = new IDatabaseColumn[] { null };
Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentNullException);
}
public static void Ctor_GivenNullColumnSet_ThrowsArgumentNullException()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
const bool enabled = true;
Assert.That(() => new OracleDatabaseKey(keyName, keyType, null, enabled), Throws.ArgumentNullException);
}
public static void Ctor_GivenNullName_ThrowsArgumentNullException()
{
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
Assert.That(() => new PostgreSqlDatabaseKey(null, keyType, columns), Throws.ArgumentNullException);
}
public static void Ctor_GivenInvalidDatabaseKeyType_ThrowsArgumentException()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = (DatabaseKeyType)55;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
Assert.That(() => new PostgreSqlDatabaseKey(keyName, keyType, columns), Throws.ArgumentException);
}
public static void Ctor_GivenNullName_ThrowsArgumentNullException()
{
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = true;
Assert.That(() => new OracleDatabaseKey(null, keyType, columns, enabled), Throws.ArgumentNullException);
}
public static void ToString_WhenInvoked_ReturnsExpectedValues(DatabaseKeyType keyType, string name, string expectedResult)
{
var keyName = Identifier.CreateQualifiedIdentifier(name);
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new PostgreSqlDatabaseKey(keyName, keyType, columns);
var result = key.ToString();
Assert.That(result, Is.EqualTo(expectedResult));
}
public static void IsEnabled_GivenRegularObject_ReturnsTrue()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new PostgreSqlDatabaseKey(keyName, keyType, columns);
Assert.That(key.IsEnabled, Is.True);
}
public static void Name_PropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new PostgreSqlDatabaseKey(keyName, keyType, columns);
Assert.That(key.Name.UnwrapSome(), Is.EqualTo(keyName));
}
public static void Columns_PropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new PostgreSqlDatabaseKey(keyName, keyType, columns);
Assert.That(key.Columns, Is.EqualTo(columns));
}
public static void IsEnabled_WhenGivenFalseInCtor_ReturnsFalse()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = false;
var key = new DatabaseKey(keyName, keyType, columns, enabled);
Assert.That(key.IsEnabled, Is.EqualTo(enabled));
}
public static void IsEnabled_PropertyGet_ReturnsTrue()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = true;
var key = new SqliteDatabaseKey(keyName, keyType, columns);
Assert.That(key.IsEnabled, Is.EqualTo(enabled));
}
public static void KeyType_PropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = true;
var key = new OracleDatabaseKey(keyName, keyType, columns, enabled);
Assert.That(key.KeyType, Is.EqualTo(keyType));
}
public static void IsEnabled_GivenFalseCtorArgAndPropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = false;
var key = new SqlServerDatabaseKey(keyName, keyType, columns, enabled);
Assert.That(key.IsEnabled, Is.EqualTo(enabled));
}
public static void ToString_WhenInvoked_ReturnsExpectedValues(DatabaseKeyType keyType, string name, string expectedResult)
{
var keyName = !name.IsNullOrWhiteSpace()
? Option <Identifier> .Some(Identifier.CreateQualifiedIdentifier(name))
: Option <Identifier> .None;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new SqliteDatabaseKey(keyName, keyType, columns);
var result = key.ToString();
Assert.That(result, Is.EqualTo(expectedResult));
}
protected Key(IEnumerable <IModelledColumn> columns, DatabaseKeyType keyType)
{
if (columns == null || columns.Empty() || columns.AnyNull())
{
throw new ArgumentNullException(nameof(columns));
}
if (!keyType.IsValid())
{
throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType));
}
Columns = columns;
KeyType = keyType;
}
/// <summary>
/// Initializes a new instance of the <see cref="SqliteDatabaseKey"/> class.
/// </summary>
/// <param name="name">The constraint name, if available.</param>
/// <param name="keyType">Type of the key constraint.</param>
/// <param name="columns">A collection of table columns.</param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> or <paramref name="columns"/> is <c>null</c>. Alternatively, if <paramref name="columns"/> is empty or has <c>null</c> values.</exception>
/// <exception cref="ArgumentException"><paramref name="keyType"/> is not a valid enum.</exception>
public SqliteDatabaseKey(Option <Identifier> name, DatabaseKeyType keyType, IEnumerable <IDatabaseColumn> columns)
{
if (columns == null || columns.Empty() || columns.AnyNull())
{
throw new ArgumentNullException(nameof(columns));
}
if (!keyType.IsValid())
{
throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType));
}
Name = name.Map(n => Identifier.CreateQualifiedIdentifier(n.LocalName));
KeyType = keyType;
Columns = columns.ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="DatabaseKey"/> class.
/// </summary>
/// <param name="name">A constraint name, if available.</param>
/// <param name="keyType">The key constraint type.</param>
/// <param name="columns">The columns covered by the key.</param>
/// <param name="isEnabled">Whether the constraint is enabled.</param>
/// <exception cref="ArgumentNullException"><paramref name="columns"/> is <c>null</c> or contains <c>null</c> values.</exception>
/// <exception cref="ArgumentException"><paramref name="keyType"/> is an invalid enum value.</exception>
public DatabaseKey(Option <Identifier> name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns, bool isEnabled)
{
if (columns == null || columns.Empty() || columns.AnyNull())
{
throw new ArgumentNullException(nameof(columns));
}
if (!keyType.IsValid())
{
throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType));
}
Name = name.Map(n => Identifier.CreateQualifiedIdentifier(n.LocalName)); // strip to localname only
KeyType = keyType;
Columns = columns;
IsEnabled = isEnabled;
}
/// <summary>
/// Initializes a new instance of the <see cref="PostgreSqlDatabaseKey"/> class.
/// </summary>
/// <param name="name">The key constraint name.</param>
/// <param name="keyType">Type of the key constraint.</param>
/// <param name="columns">A collection of table columns.</param>
/// <exception cref="ArgumentNullException"><paramref name="name"/> or <paramref name="columns"/> is <c>null</c>. Alternatively, if <paramref name="columns"/> is empty or has <c>null</c> values.</exception>
/// <exception cref="ArgumentException"><paramref name="keyType"/> is not a valid enum.</exception>
public PostgreSqlDatabaseKey(Identifier name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (columns == null || columns.Empty() || columns.AnyNull())
{
throw new ArgumentNullException(nameof(columns));
}
if (!keyType.IsValid())
{
throw new ArgumentException($"The { nameof(DatabaseKeyType) } provided must be a valid enum.", nameof(keyType));
}
Name = Option <Identifier> .Some(name.LocalName);
KeyType = keyType;
Columns = columns;
}
public ReflectionKey(Identifier name, DatabaseKeyType keyType, IReadOnlyCollection <IDatabaseColumn> columns)
: base(name, keyType, columns, true) // TODO: should we ever allow disabled keys?
{
}
public FakeKey(IEnumerable <IModelledColumn> columns, DatabaseKeyType keyType)
: base(columns, keyType)
{
}
public Key(string name, DatabaseKeyType keyType)
: this(name)
{
this.keytype = keyType;
}
