/// <summary>
/// Rename the specified column in the targeted table only if the column exists.
/// <para>IMPORTANT: In Cassandra only the Primary key can be renamed.</para>
/// </summary>
///
/// <param name="self">The instance of the Cassandra Fluent Migrator helper.</param>
/// <param name="table">The table where we want to rename the column.</param>
/// <param name="old">The column to be renamed.</param>
/// <param name="target">The new column name.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the table doesn't exists.</exception>
/// <exception cref="InvalidOperationException">Thrown when the Column is not a primary key or the target column name already exists.</exception>
public static async Task <ICassandraFluentMigrator> RenamePrimaryColumnAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string old, [NotNull] string target)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator object]");
Check.NotEmptyNotNull(table, $"The argument [table]");
Check.NotEmptyNotNull(old, $"The argument [old name]");
Check.NotEmptyNotNull(target, $"The argument [new name]");
table = table.NormalizeString();
old = old.NormalizeString();
target = target.NormalizeString();
if (!self.DoesColumnExists(table, old))
{
return(self);
}
if (self.DoesColumnExists(table, target))
{
throw new InvalidOperationException(AppErrorsMessages.TYPE_COLUMN_EXISTS.NormalizeString(target));
}
if (!self.IsPrimaryKey(table, old))
{
throw new InvalidOperationException(AppErrorsMessages.CAN_NOT_RENAME_NONE_PRIMARY_KEY.NormalizeString(old));
}
return(await self.ExecuteRenameColumnQueryAsync(table, old, target));
}
public CfmUdtExtensionsTests()
{
if (this.session is null)
{
this.session = this.GetTestCassandraSession(KEYSPACE);
this.cfmHelper = new CassandraFluentMigrator(this.session);
}
}
/// <summary>
/// Adds the specified column to the targeted table only if the column doesn't exist.
/// </summary>
///
/// <param name="self">The instance of the Cassandra Fluent Migrator helper.</param>
/// <param name="table">The table to which we want to add the new column.</param>
/// <param name="column">The new column.</param>
/// <param name="type">The column type.</param>
/// <param name="shouldBeFrozen">Define if the type should be treated as a frozen type or not.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the table doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> AddColumnAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column, [NotNull] Type type, bool shouldBeFrozen = false)
{
// Validate the parameters.
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotNull(type, $"The argument [{nameof(type)}]");
Check.NotEmptyNotNull(table, $"The argument [table]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
return(await self.ExecuteAddColumnAsync(table, column, type.GetCqlType(shouldBeFrozen)));
}
/// <summary>
/// Adds the specified column to the targeted table only if the column doesn't exist.
///
/// <para>Note: The method automatically resolve the type of the column.</para>
/// </summary>
///
/// <typeparam name="Table">The Table where we should search for the column type.</typeparam>
/// <param name="self">The instance of the Cassandra Fluent Migrator helper.</param>
/// <param name="table">The table to which we want to add the new column.</param>
/// <param name="column">The new column.</param>
/// <param name="shouldBeFrozen">Define if the type should be treated as a frozen type or not.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the table doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> AddColumnAsync <Table>([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column, bool shouldBeFrozen = false)
where Table : class
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotEmptyNotNull(table, $"The argument [{nameof(table)}]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
var typeName = self.GetColumnType <Table>(column, shouldBeFrozen);
return(await self.ExecuteAddColumnAsync(table, column, typeName));
}
public CassandraMigratorTests()
{
if (this.migrator is null)
{
var serviceProvider = this.GetTestInMemoryProvider();
var logger = serviceProvider.GetTestService <ILogger <CassandraMigrator> >();
this.migrator = new CassandraMigrator(serviceProvider, logger);
this.cfm = serviceProvider.GetTestService <ICassandraFluentMigrator>();
}
}
private static async Task <ICassandraFluentMigrator> ExecuteAddColumnAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column, [NotNull] string type)
{
table = table.NormalizeString();
column = column.NormalizeString();
type = type.NormalizeString();
if (self.DoesColumnExists(table, column))
{
return(self);
}
return(await self.ExecuteCreateColumnQueryAsync(table, column, type));
}
/// <summary>
/// Check if the specified column is a [PrimaryKey].
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="table">The Cassandra table name.</param>
/// <param name="column">The Column to check.</param>
/// <returns>True if Primary, False Otherwise.</returns>
///
/// <exception cref="ApplicationException">Thrown when the Column is not a primary key.</exception>
internal static bool IsPrimaryKey([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator object]");
Check.NotEmptyNotNull(table, $"The argument [table]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
var session = self.GetCassandraSession();
return(session
.Cluster
.Metadata
.GetTable(session.Keyspace, table.NormalizeString())
.PartitionKeys
.Any(x => x.Name.NormalizeString() == column.NormalizeString()));
}
/// <summary>
/// Alter the specified User-Defined type by adding a new column only if it doesn't exist.
/// If the UDT doesn't exists, the method throws an exception.
/// If the column exists, the method skips the action.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="udt">The name of the User-Defined type.</param>
/// <param name="column">The name of the column to be added.</param>
/// <param name="type">The type of the new column.</param>
/// <param name="shouldBeFrozen">Define if the type should be treated as a frozen type or not.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the User-Defined type doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> AlterUdtAddColumnAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string udt, string column, Type type, bool shouldBeFrozen = false)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotNull(type, $"The argument [{nameof(type)}]");
Check.NotEmptyNotNull(udt, $"The argument [User-Defined type (udt)]");
Check.NotNull(column, $"The argument [{nameof(column)}]");
if (self.DoesUdtColumnExists(udt, column))
{
return(self);
}
return(await self.ExecuteAlterUdtAddColumnQuery(udt, column, type.GetCqlType(shouldBeFrozen)));
}
/// <summary>
/// Drops the specified column from the targeted table only if the column exists.
/// </summary>
///
/// <param name="self">The instance of the Cassandra Fluent Migrator helper.</param>
/// <param name="table">The table from which we want to delete the column.</param>
/// <param name="column">The column to be deleted.</param>
/// <returns>The table Instance.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the table doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> DropColumnAsync(this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator object]");
Check.NotEmptyNotNull(table, $"The argument [{nameof(table)}]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
table = table.NormalizeString();
column = column.NormalizeString();
if (!self.DoesColumnExists(table, column))
{
return(self);
}
return(await self.ExecuteDropColumnQueryAsync(table, column));
}
private static async Task <ICassandraFluentMigrator> ExecuteStatementAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string query, [NotNull] string errorMessage)
{
try
{
IStatement statement = new SimpleStatement(query);
await self
.GetCassandraSession()
.ExecuteAsync(statement);
}
catch (Exception ex)
{
// Return the error if the message is other than the column exists.
if (!ex.Message.NormalizeString().Contains(errorMessage.NormalizeString()))
{
throw ex;
}
}
return(self);
}
public void DoesUdtExists_InvalidArguments_Faield()
{
try
{
this.cfmHelper.DoesUdtExists(null);
}
catch (NullReferenceException ex)
{
var expected = string.Format(INVALID_OR_EMPTY_ARGUMENT, "udt").ToLower();
Assert.Contains(expected, ex.Message.ToLower());
}
try
{
ICassandraFluentMigrator tempHelper = null;
tempHelper.DoesUdtExists(null);
}
catch (NullReferenceException ex)
{
Assert.Contains("Object reference not set to an instance of an object.".ToLower(), ex.Message.ToLower());
}
}
public InitialMigration(ILogger <InitialMigration> logger, ICassandraFluentMigrator cfm)
{
this.cfm = cfm;
this.logger = logger;
}
/// <summary>
/// Build and execute the Reanme column query statement.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="table">The Cassandra table name.</param>
/// <param name="column">Old Column to be renamed.</param>
/// <param name="target">New Column name.</param>
/// <returns>Cassandra Fluent Migrator.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteRenameColumnQueryAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column, [NotNull] string target)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator object]");
Check.NotEmptyNotNull(table, $"The argument [table]");
Check.NotEmptyNotNull(column, $"The argument [old name]");
Check.NotEmptyNotNull(target, $"The argument [new name]");
var query = TableCqlStatements.TABLE_RENAME_COLUMN_STATEMENT.NormalizeString(table, column, target);
return(await self.ExecuteStatementAsync(query, AppErrorsMessages.COLUMN_EXISTS_FOR_RENAME.NormalizeString(column, target, self.GetCassandraSession().Keyspace)));
}
/// <summary>
/// Delete the User-Defined type if exists.
/// If the UDT doesn't exists, the method skips the deletion.
///
/// <para>Note: If the User-Defined type name is [Null || Empty] the method will take the generic type {TEntity} name.</para>
/// </summary>
///
/// <typeparam name="TEntity">The calss where the method should look for the properties and their types.</typeparam>
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="name">The name of the udt (Optional).</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
public static async Task <ICassandraFluentMigrator> DeleteUserDefinedTypeAsync <TEntity>([NotNull] this ICassandraFluentMigrator self, [NotNull] string name = default)
where TEntity : class
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
name = string.IsNullOrWhiteSpace(name) ? typeof(TEntity).Name.NormalizeString() : name.NormalizeString();
if (!self.DoesUdtExists(name))
{
return(self);
}
return(await self.ExecuteDeleteUdtAsync <TEntity>(name));
}
/// <summary>
/// Alter the specified User-Defined type by renaming the column name by the target name.
/// If the UDT doesn't exists, the method throws an exception.
/// If the new column exists, the method throws an exception.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="udt">The name of the User-Defined type.</param>
/// <param name="column">The name of the column to be renamed.</param>
/// <param name="target">The new column name.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="InvalidOperationException">Thrown when the target column name exists.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the User-Defined type doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> AlterUdtRenameColumnAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string udt, [NotNull] string column, [NotNull] string target)
{
Check.NotNull(self, "The argument [Cassandra Fluent Migrator]");
Check.NotEmptyNotNull(udt, $"The argument [User-Defined type]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
Check.NotEmptyNotNull(target, $"The argument [{nameof(target)}]");
if (!self.DoesUdtColumnExists(udt, column))
{
return(self);
}
if (self.DoesUdtColumnExists(udt, target))
{
throw new InvalidOperationException(AppErrorsMessages.TYPE_UDT_COLUMN_EXISTS.NormalizeString(target));
}
return(await self.ExecuteAlterUdtRenameColumnQuery(udt, column, target));
}
/// <summary>
/// Alter the specified User-Defined type by adding a new column only if it doesn't exist.
/// If the UDT doesn't exists, the method throws an exception.
/// If the column exists, the method skips the action.
/// </summary>
///
/// <typeparam name="TEntity">The calss where the method should search for the properties and their types.</typeparam>
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="udt">The name of the User-Defined type.</param>
/// <param name="column">The name of the column to be added.</param>
/// <returns>The Cassandra Fluent Migrator helper.</returns>
///
/// <exception cref="NullReferenceException">Thrown when one or all the specified arguments are invalid or null.</exception>
/// <exception cref="ObjectNotFoundException">Thrown when the User-Defined type doesn't exists.</exception>
public static async Task <ICassandraFluentMigrator> AlterUdtAddColumnAsync <TEntity>([NotNull] this ICassandraFluentMigrator self, [NotNull] string udt, string column)
where TEntity : class
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotEmptyNotNull(udt, $"The argument [User-Defined type (udt)]");
Check.NotNull(column, $"The argument [{nameof(column)}]");
if (self.DoesUdtColumnExists(udt, column))
{
return(self);
}
var typeName = self.GetColumnType <TEntity>(column);
return(await self.ExecuteAlterUdtAddColumnQuery(udt, column, typeName));
}
/// <summary>
/// Build and execute the Drop column query statement.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="table">The Cassandra table name.</param>
/// <param name="column">The Column to be deleted.</param>
/// <returns>Cassandra Fluent Migrator.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteDropColumnQueryAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator object]");
Check.NotEmptyNotNull(table, $"The argument [{nameof(table)}]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
var query = TableCqlStatements.TABLE_DROP_COLUMN_STATEMENT.NormalizeString(table, column);
return(await self.ExecuteStatementAsync(query, AppErrorsMessages.COLUMN_NOT_FOUND.NormalizeString(column, table)));
}
public AddActiveColumnToUsersMigration(ILogger <AddActiveColumnToUsersMigration> logger, ICassandraFluentMigrator cfm)
{
this.cfm = cfm;
this.logger = logger;
}
/// <summary>
/// Build and execute the Add Column query statement for the User-Defined types.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="udt">The name of the User-Defined type.</param>
/// <param name="column">The name of the column to be added.</param>
/// <param name="type">The type of the column.</param>
/// <returns>The Cassandra CQL query.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteAlterUdtAddColumnQuery([NotNull] this ICassandraFluentMigrator self, [NotNull] string udt, [NotNull] string column, [NotNull] string type)
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotEmptyNotNull(udt, $"The argument [User-Defined type (udt)]");
Check.NotEmptyNotNull(type, $"The argument [{nameof(type)}]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
var query = UdtCqlStatements.TYPE_ADD_COLUMN_STATEMENT.NormalizeString(udt, column, type);
return(await self.ExecuteUdtStatementAsync(query, AppErrorsMessages.TYPE_UDT_COLUMN_EXISTS.NormalizeString(column)));
}
/// <summary>
/// Build and execute the delete User-Defined type query statement.
/// </summary>
///
/// <typeparam name="TEntity">The calss where the that represent the User-Defined type.</typeparam>
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="name">The name of the User-Defined type (Optional: will be taken from the {TEntity} if not specified).</param>
/// <returns>The Cassandra CQL query.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteDeleteUdtAsync <TEntity>([NotNull] this ICassandraFluentMigrator self, [NotNull] string name)
where TEntity : class
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotEmptyNotNull(name, $"The argument [{nameof(name)}]");
var query = UdtCqlStatements.TYPE_DROP_STATEMENT.NormalizeString(name);
return(await self.ExecuteUdtStatementAsync(query));
}
/// <summary>
/// Build and execute the create User-Defined type query statement.
/// The method automatically get the properties and their types based on the
/// {TEntity} class.
/// </summary>
///
/// <typeparam name="TEntity">The class where the method should look for the properties and their types.</typeparam>
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="name">The name of the User-Defined type.</param>
/// <param name="shouldBeFrozen">Define if the type should be treated as a frozen type or not.</param>
/// <returns>The Cassandra CQL query.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteBuildUdtAsync <TEntity>([NotNull] this ICassandraFluentMigrator self, [NotNull] string name, bool shouldBeFrozen)
where TEntity : class
{
Check.NotNull(self, $"The argument [cassandra fluent migrator]");
Check.NotEmptyNotNull(name, $"The argument [{nameof(name)}]");
var count = 0;
var properties = typeof(TEntity).GetProperties();
var query = new StringBuilder(UdtCqlStatements.TYPE_CREATE_STATEMENT.NormalizeString(name));
foreach (var property in properties)
{
var propName = property.Name.NormalizeString();
var propType = property.PropertyType.GetCqlType(shouldBeFrozen);
query.Append($"{propName} {propType}");
if (count < properties.Length - 1)
{
query.Append(", ");
count++;
}
}
var statement = query
.Append(");")
.ToString()
.NormalizeString();
return(await self.ExecuteUdtStatementAsync(statement));
}
/// <summary>
/// Build and execute the Add column query statement.
/// </summary>
///
/// <param name="self">The Cassandra Fluent Migrator.</param>
/// <param name="table">The Cassandra table name.</param>
/// <param name="column">The column that we want to add.</param>
/// <param name="type">The type of the columns.</param>
/// <returns>Cassandra Fluent Migrator.</returns>
///
/// <exception cref="NullReferenceException">Thrown when the arguments are empty or null.</exception>
internal static async Task <ICassandraFluentMigrator> ExecuteCreateColumnQueryAsync([NotNull] this ICassandraFluentMigrator self, [NotNull] string table, [NotNull] string column, [NotNull] string type)
{
Check.NotNull(self, $"The argument [table]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(column)}]");
Check.NotEmptyNotNull(column, $"The argument [{nameof(type)}]");
var query = TableCqlStatements.TABLE_ADD_COLUMN_STATEMENT.NormalizeString(table, column, type);
return(await self.ExecuteStatementAsync(query, AppErrorsMessages.COLUMN_EXISTS.NormalizeString(column)));
}
public YetAnotherChangesMigration(ILogger <YetAnotherChangesMigration> logger, ICassandraFluentMigrator cfm)
{
this.cfm = cfm;
this.logger = logger;
}
public AddingNewTypeMigration(ICassandraFluentMigrator cfmHelper)
{
this.cfmHelper = cfmHelper;
}
