public void WriteIndex(IndexDefinition index, StreamWriter output)
{
output.WriteLine("\t\t\tCreate.Index(\"" + index.Name + "\").OnTable(\"" + index.TableName + "\")");
foreach (var c in index.Columns)
{
var idx = string.Format("\t\t\t\t.OnColumn(\"{0}\")", c.Name);
if (c.Direction == Direction.Ascending)
{
idx += ".Ascending()";
}
else
{
idx += ".Descending()";
}
output.WriteLine(idx);
}
var options = "\t\t\t\t.WithOptions()";
if (index.IsClustered)
{
options += ".Clustered()";
}
else
{
options += ".NonClustered()";
}
output.WriteLine(options + ";");
}
public void ShouldApplyIndexNameConventionWhenIndexNameIsNull()
{
var indexDefinition = new IndexDefinition();
var conventions = new MigrationConventions { GetIndexName = definition => "IX_Table_Name" };
indexDefinition.ApplyConventions(conventions);
Assert.AreEqual("IX_Table_Name", indexDefinition.Name);
}
public void GetIndexNameReturnsValidIndexNameForSimpleIndex()
{
var index = new IndexDefinition
{
TableName = "Bacon",
Columns =
{
new IndexColumnDefinition { Name = "BaconName", Direction = Direction.Ascending }
}
};
DefaultMigrationConventions.GetIndexName(index).ShouldBe("IX_Bacon_BaconName");
}
public static string GetIndexName(IndexDefinition index)
{
var sb = new StringBuilder();
sb.Append("IX_");
sb.Append(index.TableName);
foreach (IndexColumnDefinition column in index.Columns)
{
sb.Append("_");
sb.Append(column.Name);
}
return sb.ToString();
}
private void LoadIndexes()
{
Indexes = IndexInfo.Read(Processor, TableMeta);
foreach (IndexInfo index in Indexes)
{
IndexDefinition indexDef = new IndexDefinition()
{
Name = index.Name,
TableName = TableMeta.Name,
IsUnique = index.IsUnique
};
index.Columns.ForEach(x => indexDef.Columns.Add(
new IndexColumnDefinition()
{
Name = x,
Direction = index.IsAscending ? Direction.Ascending : Direction.Descending
}));
Definition.Indexes.Add(indexDef);
}
}
private string GetTestMigrationWithIndex(SchemaMigrationContext context, IndexDefinition index, params ColumnDefinition[] columns)
{
var tableDefinitions = new List<TableDefinition>
{
new TableDefinition
{
Name = "Foo",
Columns = columns
}
};
if (index != null)
tableDefinitions[0].Indexes = new[] {index};
GenerateTableMigrations(context, tableDefinitions);
return File.ReadAllText(Path.Combine(_tempDirectory, @"Migrations\Test.cs"));
}
public static DeleteIndexExpression GetDeleteIndexExpression()
{
IndexDefinition indexDefinition = new IndexDefinition { Name = TestIndexName, TableName = TestTableName1 };
return new DeleteIndexExpression { Index = indexDefinition };
}
public void Truncate(IndexDefinition index)
{
index.TableName = Truncate(index.TableName);
index.Name = packKeyNames ? Pack(index.Name) : Truncate(index.Name);
index.Columns.ToList().ForEach(x => x.Name = Truncate(x.Name));
}
public DeleteIndexExpression()
{
Index = new IndexDefinition();
}
private CreateIndexExpression GetCreateIndexExpression()
{
IndexColumnDefinition indexColumnDefinition = new IndexColumnDefinition { Name = indexColumn };
IndexDefinition indexDefinition = new IndexDefinition { TableName = table, Name = indexName, Columns = new List<IndexColumnDefinition> { indexColumnDefinition } };
return new CreateIndexExpression { Index = indexDefinition };
}
protected virtual IList<IndexDefinition> ReadIndexes(string schemaName, string tableName)
{
const string query = @"SELECT OBJECT_SCHEMA_NAME(T.[object_id],DB_ID()) AS [Schema],
T.[name] AS [table_name], I.[name] AS [index_name], AC.[name] AS [column_name],
I.[type_desc], I.[is_unique], I.[data_space_id], I.[ignore_dup_key], I.[is_primary_key],
I.[is_unique_constraint], I.[fill_factor], I.[is_padded], I.[is_disabled], I.[is_hypothetical],
I.[allow_row_locks], I.[allow_page_locks], IC.[is_descending_key], IC.[is_included_column]
FROM sys.[tables] AS T
INNER JOIN sys.[indexes] I ON T.[object_id] = I.[object_id]
INNER JOIN sys.[index_columns] IC ON I.[object_id] = IC.[object_id]
INNER JOIN sys.[all_columns] AC ON T.[object_id] = AC.[object_id] AND IC.[column_id] = AC.[column_id]
WHERE T.[is_ms_shipped] = 0 AND I.[type_desc] <> 'HEAP'
AND T.object_id = OBJECT_ID('[{0}].[{1}]')
ORDER BY T.[name], I.[index_id], IC.[key_ordinal]";
DataSet ds = Read(query, schemaName, tableName);
DataTable dt = ds.Tables[0];
IList<IndexDefinition> indexes = new List<IndexDefinition>();
foreach (DataRow dr in dt.Rows)
{
List<IndexDefinition> matches = (from i in indexes
where i.Name == dr["index_name"].ToString()
&& i.SchemaName == dr["Schema"].ToString()
select i).ToList();
IndexDefinition iDef = null;
if (matches.Count > 0) iDef = matches[0];
// create the table if not found
if (iDef == null)
{
iDef = new IndexDefinition
{
Name = dr["index_name"].ToString(),
SchemaName = dr["Schema"].ToString(),
IsClustered = dr["type_desc"].ToString() == "CLUSTERED",
IsUnique = dr["is_unique"].ToString() == "1",
TableName = dr["table_name"].ToString()
};
indexes.Add(iDef);
}
// columns
ICollection<IndexColumnDefinition> ms = (from m in iDef.Columns
where m.Name == dr["column_name"].ToString()
select m).ToList();
if (ms.Count == 0)
{
iDef.Columns.Add(new IndexColumnDefinition
{
Name = dr["column_name"].ToString(),
Direction = dr["is_descending_key"].ToString() == "1" ? Direction.Descending : Direction.Ascending
});
}
}
return indexes;
}
public CreateIndexExpression()
{
Index = new IndexDefinition();
}
protected virtual IndexDefinition ParseCreateIndexStatement(SqliteSyntaxReader reader)
{
var index = new IndexDefinition();
reader.Read();
reader.Read();
index.IsUnique = reader.ValueToUpper == "UNIQUE";
while (reader.ValueToUpper != "INDEX") reader.Read();
if (reader.Read() == SqliteSyntaxReader.TokenType.StringToken && reader.ValueToUpper == "IF")
{
reader.Read(); // NOT
reader.Read(); // EXISTS
}
else
{
reader.Rollback();
}
index.Name = ParseIdentifier(reader);
reader.Read(); // ON
index.TableName = ParseIdentifier(reader);
// Find Column List
reader.SkipTillToken(SqliteSyntaxReader.TokenType.ListStart);
// Split the list.
var list = reader.ReadList();
foreach (var columnReader in list)
{
var column = new IndexColumnDefinition();
column.Name = ParseIdentifier(columnReader);
while (columnReader.Read() == SqliteSyntaxReader.TokenType.StringToken)
{
if (columnReader.ValueToUpper == "COLLATE")
{
columnReader.Read(); // Skip Collation name
}
else if (columnReader.ValueToUpper == "DESC")
{
column.Direction = Direction.Descending;
}
}
index.Columns.Add(column);
}
return index;
}
protected virtual IList<IndexDefinition> ReadIndexes(string schemaName, string tableName)
{
var sqlCommand = string.Format(@"SELECT type, name, sql FROM sqlite_master WHERE tbl_name = '{0}' AND type = 'index' AND name NOT LIKE 'sqlite_auto%';", tableName);
DataTable table = Read(sqlCommand).Tables[0];
IList<IndexDefinition> indexes = new List<IndexDefinition>();
foreach (DataRow dr in table.Rows)
{
var sql = dr["sql"].ToString();
var upper = sql.ToUpper();
var columnsString = GetTextBeteenBrackets(sql);
var iDef = new IndexDefinition
{
Name = dr["name"].ToString(),
SchemaName = schemaName,
IsClustered = false,
IsUnique = upper.Contains("UNIQUE"),
TableName = tableName,
Columns = GetIndexColumnsFromIndexDDL(columnsString)
};
indexes.Add(iDef);
}
return indexes;
}
private DeleteIndexExpression GetDeleteIndexExpression()
{
IndexDefinition indexDefinition = new IndexDefinition { Name = indexName};
return new DeleteIndexExpression { Index = indexDefinition };
}
private void WriteIndex(StreamWriter output, IndexDefinition index, SchemaMigrationContext context)
{
output.WriteLine("\t\t\tCreate.Index(\"" + index.Name + "\").OnTable(\"" + index.TableName + "\")");
foreach (var column in index.Columns)
{
output.Write("\t\t\t\t.OnColumn(\"" + column.Name + "\")");
if ( column.Direction == Direction.Ascending)
output.Write(".Ascending()");
if (column.Direction == Direction.Descending)
output.Write(".Descending()");
}
if ( index.IsUnique || index.IsClustered )
{
output.Write(".WithOptions()");
if ( index.IsUnique )
output.Write(".Unique()");
if (index.IsClustered)
output.Write(".Clustered()");
}
output.WriteLine(";");
}
private static void WriteDeleteIndex(StreamWriter output, IndexDefinition index)
{
output.WriteLine("\t\t\tDelete.Index(\"" + index.Name + "\");");
}
