/// <remarks>
/// Primary keys are handled as in <see cref="GetConstraints"/>, not here
/// </remarks>
protected virtual void GetIndexes(
DbConnection connection,
IReadOnlyList <DatabaseTable> tables,
Func <string, string, bool> tableFilter)
{
foreach (var table in tables)
{
using (var command = connection.CreateCommand())
{
command.CommandText = string.Format(GetIndexesQuery, connection.Database, table.Name);
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
try
{
var index = new DatabaseIndex
{
Table = table, Name = reader.GetValueOrDefault <string>("INDEX_NAME"),
IsUnique = !reader.GetValueOrDefault <bool>("NON_UNIQUE"),
};
foreach (var column in reader.GetValueOrDefault <string>("COLUMNS").Split(','))
{
index.Columns.Add(table.Columns.Single(y => y.Name == column));
}
var prefixLengths = reader.GetValueOrDefault <string>("SUB_PARTS")
.Split(',')
.Select(int.Parse)
.ToArray();
if (prefixLengths.Length > 1 ||
prefixLengths.Length == 1 && prefixLengths[0] > 0)
{
index[MySqlAnnotationNames.IndexPrefixLength] = prefixLengths;
}
var indexType = reader.GetValueOrDefault <string>("INDEX_TYPE");
if (string.Equals(indexType, "spatial", StringComparison.OrdinalIgnoreCase))
{
index[MySqlAnnotationNames.SpatialIndex] = true;
}
if (string.Equals(indexType, "fulltext", StringComparison.OrdinalIgnoreCase))
{
index[MySqlAnnotationNames.FullTextIndex] = true;
}
table.Indexes.Add(index);
}
catch (Exception ex)
{
_logger.Logger.LogError(ex, "Error assigning index for {table}.", table.Name);
}
}
}
}
}
}
protected virtual bool AcceptIndex(DatabaseIndex index) => true;
private IEnumerable <DatabaseIndex> GetIndexes(
DbConnection connection,
string table,
IList <DatabaseColumn> columns)
{
using (var command1 = connection.CreateCommand())
{
command1.CommandText = new StringBuilder()
.AppendLine("SELECT \"name\", \"unique\"")
.AppendLine("FROM pragma_index_list(@table)")
.AppendLine("WHERE \"origin\" = 'c' AND instr(\"name\", 'Taos_') <> 1")
.AppendLine("ORDER BY \"seq\";")
.ToString();
var parameter1 = command1.CreateParameter();
parameter1.ParameterName = "@table";
parameter1.Value = table;
command1.Parameters.Add(parameter1);
using (var reader1 = command1.ExecuteReader())
{
while (reader1.Read())
{
var index = new DatabaseIndex
{
Name = reader1.GetString(0),
IsUnique = reader1.GetBoolean(1)
};
_logger.IndexFound(index.Name, table, index.IsUnique);
using (var command2 = connection.CreateCommand())
{
command2.CommandText = new StringBuilder()
.AppendLine("SELECT \"name\"")
.AppendLine("FROM pragma_index_info(@index)")
.AppendLine("ORDER BY \"seqno\";")
.ToString();
var parameter2 = command2.CreateParameter();
parameter2.ParameterName = "@index";
parameter2.Value = index.Name;
command2.Parameters.Add(parameter2);
using (var reader2 = command2.ExecuteReader())
{
while (reader2.Read())
{
var name = reader2.GetString(0);
var column = columns.FirstOrDefault(c => c.Name == name)
?? columns.FirstOrDefault(c => c.Name.Equals(name, StringComparison.Ordinal));
Debug.Assert(column != null, "column is null.");
index.Columns.Add(column);
}
}
}
yield return(index);
}
}
}
}
protected override MigrationOperation Drop(DatabaseIndex index) => AddMemoryOptimizedAnnotation(base.Drop(index), index.Table);
private void GetIndexes()
{
var command = _connection.CreateCommand();
command.CommandText = @"SELECT
object_schema_name(i.object_id) AS [schema_name],
object_name(i.object_id) AS [table_name],
i.name AS [index_name],
i.is_unique,
c.name AS [column_name],
i.type_desc,
ic.key_ordinal,
i.has_filter,
i.filter_definition
FROM sys.indexes i
INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
INNER JOIN sys.columns c ON ic.object_id = c.object_id AND c.column_id = ic.column_id
INNER JOIN sys.tables t ON t.object_id = i.object_id
WHERE object_schema_name(i.object_id) <> 'sys'
AND i.is_hypothetical = 0
AND i.is_primary_key <> 1
AND i.is_unique_constraint <> 1
AND object_name(i.object_id) <> '" + HistoryRepository.DefaultTableName + @"'" +
TemporalTableWhereClause + @"
ORDER BY object_schema_name(i.object_id), object_name(i.object_id), i.name, ic.key_ordinal";
using (var reader = command.ExecuteReader())
{
DatabaseIndex index = null;
while (reader.Read())
{
var schemaName = reader.GetValueOrDefault <string>("schema_name");
var tableName = reader.GetValueOrDefault <string>("table_name");
var indexName = reader.GetValueOrDefault <string>("index_name");
var isUnique = reader.GetValueOrDefault <bool>("is_unique");
var typeDesc = reader.GetValueOrDefault <string>("type_desc");
var columnName = reader.GetValueOrDefault <string>("column_name");
var indexOrdinal = reader.GetValueOrDefault <byte>("key_ordinal");
var hasFilter = reader.GetValueOrDefault <bool>("has_filter");
var filterDefinition = reader.GetValueOrDefault <string>("filter_definition");
Logger.IndexColumnFound(
DisplayName(schemaName, tableName), indexName, isUnique, columnName, indexOrdinal);
if (!_tableSelectionSet.Allows(schemaName, tableName))
{
Logger.IndexColumnSkipped(columnName, indexName, DisplayName(schemaName, tableName));
continue;
}
if (string.IsNullOrEmpty(indexName))
{
Logger.IndexNotNamedWarning(DisplayName(schemaName, tableName));
continue;
}
Debug.Assert(index == null || index.Table != null);
if (index == null ||
index.Name != indexName
// ReSharper disable once PossibleNullReferenceException
|| index.Table.Name != tableName ||
index.Table.Schema != schemaName)
{
DatabaseTable table;
if (!_tables.TryGetValue(SchemaQualifiedKey(tableName, schemaName), out table))
{
Logger.IndexTableMissingWarning(indexName, DisplayName(schemaName, tableName));
continue;
}
index = new DatabaseIndex
{
Table = table,
Name = indexName,
IsUnique = isUnique,
Filter = hasFilter ? filterDefinition : null
};
if (typeDesc == "CLUSTERED")
{
index[SqlServerAnnotationNames.Clustered] = true;
}
table.Indexes.Add(index);
}
DatabaseColumn column;
if (string.IsNullOrEmpty(columnName))
{
Logger.IndexColumnNotNamedWarning(indexName, DisplayName(schemaName, tableName));
}
else if (!_tableColumns.TryGetValue(ColumnKey(index.Table, columnName), out column))
{
Logger.IndexColumnsNotMappedWarning(indexName, new[] { columnName });
}
else
{
index.Columns.Add(column);
}
}
}
}
private void mnuFilterInstance_Click(object sender, RoutedEventArgs e)
{
DatabaseIndex index = (DatabaseIndex)((MenuItem)sender).DataContext;
comboboxInstances.Text = index.InstanceId.ToHex();
}
protected override MigrationOperation Drop(DatabaseIndex index) => AddSqlServerSpecificAnnotations(base.Drop(index), index.Table);
public static IList <DatabaseColumn> GetColumns(this DatabaseIndex index)
{
return(index.Columns);
}
protected override bool AcceptIndex(DatabaseIndex index)
=> !index.Name.StartsWith("PK_", StringComparison.Ordinal) &&
!index.Name.StartsWith("AK_", StringComparison.Ordinal);
void GetIndexes()
{
var command = _connection.CreateCommand();
var dbName = _connection.Database;
command.CommandText = $@"SELECT DISTINCT
s.table_schema,
s.table_name,
s.non_unique,
s.index_name,
s.column_name,
s.seq_in_index,
t.constraint_type
FROM information_schema.statistics s
LEFT OUTER JOIN information_schema.table_constraints t
ON t.table_schema=s.table_schema
AND t.table_name=s.table_name
AND s.index_name=t.constraint_name
WHERE LOWER(s.table_schema) IN ({_schemaList.ToLowerInvariant()})
AND s.table_name NOT LIKE '{HistoryRepository.DefaultTableName}'
AND s.index_name <> 'PRIMARY'
ORDER BY s.table_schema, s.table_name, s.non_unique, s.index_name, s.seq_in_index";
using (var reader = command.ExecuteReader())
{
DatabaseIndex index = null;
while (reader.Read())
{
var tableSchema = reader.GetValueOrDefault <string>("table_schema");
var tableName = reader.GetValueOrDefault <string>("table_name");
var indexName = reader.GetValueOrDefault <string>("index_name");
var isUnique = reader.GetInt32("non_unique") == 0 ? true : false;
var columnName = reader.GetValueOrDefault <string>("column_name");
var indexOrdinal = reader.GetInt32("seq_in_index");
if (!_tableSelectionSet.Allows(tableSchema, tableName))
{
Logger.LogDebug("Index column skipped", new string[] { columnName, indexName, tableSchema, tableName });
continue;
}
if (string.IsNullOrEmpty(indexName))
{
Logger.LogWarning("Index unnamed", new string[] { tableSchema, tableName });
continue;
}
if (index == null || index.Name != indexName || index.Table.Name != tableName || index.Table.Schema != tableSchema)
{
DatabaseTable table = null;
if (!_tables.TryGetValue(TableKey(tableName, tableSchema), out table))
{
Logger.LogWarning("Index table missing", new string[] { indexName, tableSchema, tableName });
continue;
}
index = new DatabaseIndex
{
Table = table,
Name = indexName,
IsUnique = isUnique
};
table.Indexes.Add(index);
}
DatabaseColumn column;
if (string.IsNullOrEmpty(columnName))
{
Logger.LogWarning("Index column must be named", new string[] { tableSchema, tableName, indexName });
}
else if (!_tableColumns.TryGetValue(ColumnKey(index.Table, columnName), out column))
{
Logger.LogWarning("Index columns not mapped", new string[] { indexName, columnName, tableSchema, tableName });
}
else
{
index.Columns.Add(column);
}
}
}
}
public static DatabaseColumn GetColumn(this DatabaseIndex index)
{
return(index.Columns.Single());
}
private void GetIndexes(DbConnection connection, IReadOnlyList <DatabaseTable> tables)
{
var indexTable = new DataTable();
using (var command = connection.CreateCommand())
{
command.CommandText = $@"SELECT * FROM `INFORMATION_SCHEMA.INDEXES` ORDER BY TABLE_NAME, INDEX_NAME";
using var reader = command.ExecuteReader();
indexTable.Load(reader);
}
var indexColumnsTable = new DataTable();
using (var command = connection.CreateCommand())
{
command.CommandText = "SELECT * FROM `INFORMATION_SCHEMA.INDEX_COLUMNS` ORDER BY TABLE_NAME, INDEX_NAME, ORDINAL_POSITION";
using var reader = command.ExecuteReader();
indexColumnsTable.Load(reader);
}
var groupedIndexColumns = indexColumnsTable.Rows.Cast <DataRow>()
.GroupBy(r => (TableName: r.GetValueOrDefault <string>("TABLE_NAME"), IndexName: r.GetValueOrDefault <string>("INDEX_NAME")))
.ToList();
foreach (DataRow indexRow in indexTable.Rows)
{
var tableName = indexRow.GetValueOrDefault <string>("TABLE_NAME");
var indexName = indexRow.GetValueOrDefault <string>("INDEX_NAME");
var indexType = indexRow.GetValueOrDefault <string>("INDEX_TYPE");
var nullable = indexRow.GetValueOrDefault <bool>("IS_NULLABLE");
var ignoresNulls = indexRow.GetValueOrDefault <bool>("IGNORES_NULLS");
var table = tables.FirstOrDefault(t => string.Equals(t.Name, tableName)) ??
tables.FirstOrDefault(t => string.Equals(t.Name, tableName, StringComparison.OrdinalIgnoreCase));
if (table != null)
{
var indexColumns = groupedIndexColumns.FirstOrDefault(g => g.Key == (tableName, indexName));
if (indexColumns?.Any() ?? false)
{
object indexOrKey = null;
if (indexType == "PRIMARY")
{
var primaryKey = new DatabasePrimaryKey
{
Table = table,
Name = indexName,
};
_logger.PrimaryKeyFound(indexName, tableName);
table.PrimaryKey = primaryKey;
indexOrKey = primaryKey;
}
else if (indexType == "UNIQUE" &&
!nullable)
{
var uniqueConstraint = new DatabaseUniqueConstraint
{
Table = table,
Name = indexName,
};
_logger.UniqueConstraintFound(indexName, tableName);
table.UniqueConstraints.Add(uniqueConstraint);
indexOrKey = uniqueConstraint;
}
else
{
var index = new DatabaseIndex
{
Table = table,
Name = indexName,
IsUnique = indexType == "UNIQUE",
};
_logger.IndexFound(indexName, tableName, index.IsUnique);
table.Indexes.Add(index);
indexOrKey = index;
}
foreach (var indexColumn in indexColumns)
{
var columnName = indexColumn.GetValueOrDefault <string>("COLUMN_NAME");
var descending = indexColumn.GetValueOrDefault <bool>("IS_DESCENDING");
var column = table.Columns.FirstOrDefault(c => c.Name == columnName) ??
table.Columns.FirstOrDefault(c => string.Equals(c.Name, columnName, StringComparison.OrdinalIgnoreCase));
if (column != null)
{
switch (indexOrKey)
{
case DatabasePrimaryKey primaryKey:
primaryKey.Columns.Add(column);
break;
case DatabaseUniqueConstraint uniqueConstraint:
uniqueConstraint.Columns.Add(column);
break;
case DatabaseIndex index:
index.Columns.Add(column);
break;
}
}
}
}
}
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is DatabaseIndex || value is uint)
{
uint?typeId = null;
uint?instanceType = null;
if (value is DatabaseIndex)
{
DatabaseIndex index = value as DatabaseIndex;
//get the icon based on the abbreviation
typeId = index.TypeId;
instanceType = index.InstanceType;
}
else if (value is uint)
{
typeId = value as uint?;
}
if (typeId != null)
{
if (typeId != (uint)TypeIds.PropertyFile)
{
BitmapImage image = new BitmapImage(new Uri(string.Format(@"/SimCityPak;component/Images/InstanceTypeIcons/16x16_{0}.png", TGIRegistry.Instance.FileTypes.GetAbbreviation(typeId.Value).Trim()), UriKind.Relative));
return(image);
}
else if (instanceType != null)
{
switch ((PropertyFileTypeIds)instanceType)
{
case PropertyFileTypeIds.Agent: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_AGENT.png", UriKind.Relative))); //AGENT
case PropertyFileTypeIds.Path: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_PATH.png", UriKind.Relative))); //PATH
case PropertyFileTypeIds.Unit: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_UNIT.png", UriKind.Relative))); //UNIT
case PropertyFileTypeIds.Network: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_NETWORK.png", UriKind.Relative))); //MAP
case PropertyFileTypeIds.Menu: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_MENU.png", UriKind.Relative))); //MENU
case PropertyFileTypeIds.Menu2: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_MENU.png", UriKind.Relative))); //MENU
case PropertyFileTypeIds.Map: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_MAP.png", UriKind.Relative))); //MAP
case PropertyFileTypeIds.Descriptor: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_DESC.png", UriKind.Relative))); //MAP
case PropertyFileTypeIds.DecalAtlas: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_DECALATLAS.png", UriKind.Relative)));
case PropertyFileTypeIds.DecalAtlas2: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_DECALATLAS.png", UriKind.Relative)));
case PropertyFileTypeIds.DecalAtlas3: return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/PROP/16x16_DECALATLAS.png", UriKind.Relative)));
}
return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/16x16_PROP.png", UriKind.Relative)));
}
else
{
return(new BitmapImage(new Uri(@"/SimCityPak;component/Images/InstanceTypeIcons/16x16_PROP.png", UriKind.Relative)));
}
}
}
return(null);
}
public FulltextIndexPopulator(FulltextIndexDescriptor descriptor, DatabaseIndex <FulltextIndexReader> luceneFulltext, ThrowingAction <IOException> descriptorCreateAction) : base(luceneFulltext)
{
this._descriptor = descriptor;
this._descriptorCreateAction = descriptorCreateAction;
}
private void mnuCopyInstance_Click(object sender, RoutedEventArgs e)
{
DatabaseIndex index = (DatabaseIndex)((MenuItem)sender).DataContext;
Clipboard.SetText(index.InstanceId.ToHex());
}
private void CreateLotModel()
{
//Create the plane representing the lot (texture & size)
if (UnitFileEntry.LotOverlayBoxSize != null)
{
Vector2Property lotSize = UnitFileEntry.LotOverlayBoxSize;
RectangleVisual3D groundPlane = new RectangleVisual3D();
groundPlane.Width = (lotSize.X);
groundPlane.Length = (lotSize.Y);
groundPlane.Transform = new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(0, 0, 1), -90));
if (UnitFileEntry.LotOverlayBoxOffset != null)
{
// groundPlane.Transform = Transform3DHelper.CombineTransform(groundPlane.Transform, new TranslateTransform3D(-1 * UnitFileEntry.LotOverlayBoxOffset.X, -1 * UnitFileEntry.LotOverlayBoxOffset.Y, 0));
}
if (UnitFileEntry.LotPlacementTransform != null && UnitFileEntry.LotPlacementTransform.Count > 0)
{
groundPlane.Transform = Transform3DHelper.CombineTransform(groundPlane.Transform, (Transform3D) new MatrixTransform3D(UnitFileEntry.LotPlacementTransform[0].GetAsMatrix3D()).Inverse);
}
if (UnitFileEntry.LotMask != null)
{
DatabaseIndex index = DatabaseManager.Instance.Indices.Find(k => k.InstanceId == UnitFileEntry.LotMask.InstanceId && k.TypeId == 0x2f4e681c);
if (index != null)
{
Color color1 = Colors.Black;
Color color2 = Colors.Red;
Color color3 = Colors.Green;
Color color4 = Colors.Blue;
if (UnitFileEntry.LotColor1 != null)
{
color1 = Color.FromRgb((byte)(255 * UnitFileEntry.LotColor1.R), (byte)(255 * UnitFileEntry.LotColor1.G), (byte)(255 * UnitFileEntry.LotColor1.B));
}
if (UnitFileEntry.LotColor2 != null)
{
color2 = Color.FromRgb((byte)(255 * UnitFileEntry.LotColor2.R), (byte)(255 * UnitFileEntry.LotColor2.G), (byte)(255 * UnitFileEntry.LotColor2.B));
}
if (UnitFileEntry.LotColor3 != null)
{
color3 = Color.FromRgb((byte)(255 * UnitFileEntry.LotColor3.R), (byte)(255 * UnitFileEntry.LotColor3.G), (byte)(255 * UnitFileEntry.LotColor3.B));
}
if (UnitFileEntry.LotColor4 != null)
{
color4 = Color.FromRgb((byte)(255 * UnitFileEntry.LotColor4.R), (byte)(255 * UnitFileEntry.LotColor4.G), (byte)(255 * UnitFileEntry.LotColor4.B));
}
using (MemoryStream byteStream = new MemoryStream(index.GetIndexData(true)))
{
RasterImage rasterImage = RasterImage.CreateFromStream(byteStream, RasterChannel.Preview, color4, color3, color2, color1);
groundPlane.Material = new DiffuseMaterial(new ImageBrush(rasterImage.MipMaps[0]));
}
}
groundPlane.BackMaterial = new DiffuseMaterial(new SolidColorBrush(Colors.Transparent));
}
viewPort.Children.Add(groundPlane);
}
}
private void mnuFilterGroup_Click(object sender, RoutedEventArgs e)
{
DatabaseIndex index = (DatabaseIndex)((MenuItem)sender).DataContext;
comboboxGroups.Text = index.GroupContainer.ToHex();
}
public void GenerateRasterImage(string originalFile)
{
if (!string.IsNullOrEmpty(originalFile))
{
try
{
nQuant.WuQuantizer quantizer = new nQuant.WuQuantizer();
System.Drawing.Bitmap bitmap = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile(originalFile);
quantizer.QuantizeImage(bitmap);
QuantizedSignedDistanceFieldGenerator generator = new QuantizedSignedDistanceFieldGenerator(quantizer.Palette, bitmap.Height, bitmap.Width);
generator.Generate(0);
generator.Generate(1);
generator.Generate(2);
generator.Generate(3);
RasterImage RasterResult = RasterImage.CreateFromBitmap(generator.GetBitmap());
uint InstanceId = TGIRandomGenerator.GetNext();
DatabaseIndex newIndex = new DatabaseIndex(OriginalIndex.Owner);
newIndex.TypeId = (uint)TypeIds.RasterFile;
newIndex.InstanceId = InstanceId;
newIndex.Flags = 1;
newIndex.IsModified = true;
newIndex.Compressed = false;
newIndex.ModifiedData = new ModifiedRasterFile()
{
ImageFileData = RasterResult.ToIndexData()
};
OriginalIndex.Owner.Indices.Add(newIndex);
SimCityPak.PackageReader.DatabaseManager.Instance.Indices.Add(newIndex);
UnitFileEntry.LotMask.InstanceId = InstanceId;
//quantizer.Palette.Colors[0].Scr
Color col = Color.FromArgb(quantizer.Palette.Colors[0].A, quantizer.Palette.Colors[0].R, quantizer.Palette.Colors[0].G, quantizer.Palette.Colors[0].B);
UnitFileEntry.LotColor4.R = col.ScR;
UnitFileEntry.LotColor4.G = col.ScG;
UnitFileEntry.LotColor4.B = col.ScB;
col = Color.FromArgb(quantizer.Palette.Colors[1].A, quantizer.Palette.Colors[1].R, quantizer.Palette.Colors[1].G, quantizer.Palette.Colors[1].B);
UnitFileEntry.LotColor1.R = col.ScR;
UnitFileEntry.LotColor1.G = col.ScG;
UnitFileEntry.LotColor1.B = col.ScB;
col = Color.FromArgb(quantizer.Palette.Colors[2].A, quantizer.Palette.Colors[2].R, quantizer.Palette.Colors[2].G, quantizer.Palette.Colors[2].B);
UnitFileEntry.LotColor2.R = col.ScR;
UnitFileEntry.LotColor2.G = col.ScG;
UnitFileEntry.LotColor2.B = col.ScB;
col = Color.FromArgb(quantizer.Palette.Colors[3].A, quantizer.Palette.Colors[3].R, quantizer.Palette.Colors[3].G, quantizer.Palette.Colors[3].B);
UnitFileEntry.LotColor3.R = col.ScR;
UnitFileEntry.LotColor3.G = col.ScG;
UnitFileEntry.LotColor3.B = col.ScB;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error during generation", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void mnuCopyKey_Click(object sender, RoutedEventArgs e)
{
DatabaseIndex index = (DatabaseIndex)((MenuItem)sender).DataContext;
Clipboard.SetText(index.TypeId.ToHex() + "-" + index.GroupContainer.ToHex() + "-" + index.InstanceId.ToHex());
}
private void GetIndexes()
{
var command = _connection.CreateCommand();
command.CommandText = @"SELECT
ix.[INDEX_NAME] AS [index_name],
NULL AS [schema_name],
ix.[TABLE_NAME] AS [table_name],
ix.[UNIQUE] AS is_unique,
ix.[COLUMN_NAME] AS [column_name],
ix.[ORDINAL_POSITION]
FROM INFORMATION_SCHEMA.INDEXES ix
WHERE ix.PRIMARY_KEY = 0
AND ix.[UNIQUE] = 0
AND (SUBSTRING(TABLE_NAME, 1,2) <> '__')
AND (SUBSTRING(ix.COLUMN_NAME, 1,5) != '__sys')
ORDER BY ix.[TABLE_NAME], ix.[INDEX_NAME], ix.[ORDINAL_POSITION];";
using (var reader = command.ExecuteReader())
{
DatabaseIndex index = null;
while (reader.Read())
{
var indexName = reader.GetValueOrDefault <string>("index_name");
var tableName = reader.GetValueOrDefault <string>("table_name");
var columnName = reader.GetValueOrDefault <string>("column_name");
if (!AllowsTable(tablesToSelect, selectedTables, tableName))
{
continue;
}
if ((index == null) ||
(index.Name != indexName))
{
DatabaseTable table;
if (!_tables.TryGetValue(TableKey(tableName), out table))
{
continue;
}
index = new DatabaseIndex
{
Table = table,
Name = indexName,
IsUnique = reader.GetValueOrDefault <bool>("is_unique")
};
table.Indexes.Add(index);
}
DatabaseColumn column;
if (!_tableColumns.TryGetValue(ColumnKey(index.Table, columnName), out column))
{
//Logger.IndexColumnsNotMappedWarning(indexName, new[] { columnName });
}
else
{
index.Columns.Add(column);
}
}
}
}
public static FbIndexModelAnnotations Firebird(this DatabaseIndex index) => new FbIndexModelAnnotations(index);
protected override DropIndexOperation Drop(DatabaseIndex index) => AdDOptimizedAnnotation(base.Drop(index), index.Table);
private void GetIndexes(
DbConnection connection,
string tableFilter,
DatabaseModel databaseModel)
{
using (var command = connection.CreateCommand())
{
var queryBuilder = new StringBuilder()
.AppendLine("SELECT")
.AppendLine(" b.tablespace_name,")
.AppendLine(" b.uniqueness,")
.AppendLine(" a.index_name,")
.AppendLine(" a.table_name,")
.AppendLine(" a.column_name")
.AppendLine("FROM all_ind_columns a")
.AppendLine("INNER JOIN all_indexes b")
.AppendLine(" ON a.index_name = b.index_name")
.AppendLine("INNER JOIN user_tables t")
.AppendLine(" ON t.table_name = a.table_name")
.AppendLine(tableFilter)
.AppendLine("ORDER BY a.table_name, a.index_name, a.column_position");
command.CommandText = queryBuilder.ToString();
using (var reader = command.ExecuteReader())
{
var tableIndexGroups = reader.Cast <DbDataRecord>()
.GroupBy(
ddr => (tableSchema: ddr.GetValueOrDefault <string>("tablespace_name"),
tableName: ddr.GetValueOrDefault <string>("table_name")));
foreach (var tableIndexGroup in tableIndexGroups)
{
var tableSchema = tableIndexGroup.Key.tableSchema;
var tableName = tableIndexGroup.Key.tableName;
var table = databaseModel.Tables.Single(t => t.Schema == tableSchema && t.Name == tableName);
var indexGroups = tableIndexGroup
.GroupBy(
ddr =>
(Name: ddr.GetValueOrDefault <string>("index_name"),
IsUnique: ddr.GetValueOrDefault <string>("uniqueness").Equals("UNIQUE")))
.ToArray();
foreach (var indexGroup in indexGroups)
{
_logger.IndexFound(indexGroup.Key.Name, DisplayName(tableSchema, tableName), indexGroup.Key.IsUnique);
var index = new DatabaseIndex
{
Table = table,
Name = indexGroup.Key.Name,
IsUnique = indexGroup.Key.IsUnique
};
foreach (var dataRecord in indexGroup)
{
var columnName = dataRecord.GetValueOrDefault <string>("column_name");
var column = table.Columns.FirstOrDefault(c => c.Name == columnName)
?? table.Columns.FirstOrDefault(c => c.Name.Equals(columnName, StringComparison.OrdinalIgnoreCase));
index.Columns.Add(column);
}
table.Indexes.Add(index);
}
}
}
}
}
public FbIndexModelAnnotations(DatabaseIndex index)
{
_index = index;
}
public string DropIndex(DatabaseTable databaseTable, DatabaseIndex index)
{
return(_migration.DropIndex(databaseTable, index));
}
private static void ConvertIndexes(DataTable dt, ICollection <DatabaseIndex> indexes)
{
if (dt == null)
{
return;
}
//Npgsql
if (dt.Columns.Count == 0)
{
return;
}
var indexKeyMap = new IndexKeyMap(dt);
foreach (DataRowView row in dt.DefaultView)
{
string name = row[indexKeyMap.Key].ToString();
if (string.IsNullOrEmpty(name))
{
continue; //all indexes should have a name
}
string schema = !String.IsNullOrEmpty(indexKeyMap.SchemaKey) ? row[indexKeyMap.SchemaKey].ToString() : String.Empty;
var tableName = row[indexKeyMap.TableKey].ToString();
var c = indexes.FirstOrDefault(f => f.Name == name && f.SchemaOwner == schema && f.TableName.Equals(tableName, StringComparison.OrdinalIgnoreCase));
if (c == null)
{
c = new DatabaseIndex();
c.Name = name;
c.SchemaOwner = schema;
c.TableName = tableName;
if (indexKeyMap.Typekey != null)
{
c.IndexType = row[indexKeyMap.Typekey].ToString();
}
if (FindBoolean(row, indexKeyMap.UniqueKey, "UNIQUE"))
{
c.IsUnique = true;
c.IndexType = "UNIQUE";
}
if (FindBoolean(row, indexKeyMap.PrimaryKey, String.Empty))
{
c.IndexType = "PRIMARY"; //primary keys should be unique too
}
indexes.Add(c);
}
if (string.IsNullOrEmpty(indexKeyMap.ColumnKey))
{
continue;
}
string colName = row[indexKeyMap.ColumnKey].ToString();
if (string.IsNullOrEmpty(colName))
{
continue;
}
var column = new DatabaseColumn();
column.Name = colName;
if (!string.IsNullOrEmpty(indexKeyMap.OrdinalKey))
{
int ordinal = Convert.ToInt32(row[indexKeyMap.OrdinalKey], CultureInfo.CurrentCulture);
column.Ordinal = ordinal;
}
if (ContainsColumn(c.Columns, colName))
{
continue;
}
c.Columns.Add(column);
if (c.Columns.Count > 1 && column.Ordinal != 0)
{
//the order of the datatable may be wrong
c.Columns.Sort((x, y) => x.Ordinal.CompareTo(y.Ordinal));
}
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
protected virtual IndexBuilder VisitIndex([NotNull] EntityTypeBuilder builder, [NotNull] DatabaseIndex index)
{
Check.NotNull(builder, nameof(builder));
Check.NotNull(index, nameof(index));
var unmappedColumns = index.Columns
.Where(c => _unmappedColumns.Contains(c))
.Select(c => c.Name)
.ToList();
if (unmappedColumns.Count > 0)
{
_reporter.WriteWarning(
DesignStrings.UnableToScaffoldIndexMissingProperty(
index.Name,
string.Join(CultureInfo.CurrentCulture.TextInfo.ListSeparator, unmappedColumns)));
return(null);
}
var propertyNames = index.Columns.Select(GetPropertyName).ToArray();
var indexBuilder = builder.HasIndex(propertyNames)
.IsUnique(index.IsUnique);
if (index.Filter != null)
{
indexBuilder.HasFilter(index.Filter);
}
if (!string.IsNullOrEmpty(index.Name) &&
index.Name != indexBuilder.Metadata.GetDefaultName())
{
indexBuilder.HasName(index.Name);
}
indexBuilder.Metadata.AddAnnotations(index.GetAnnotations());
return(indexBuilder);
}
public PackagePack(Stream output, string sourceFolder, PleaseWait progress)
{
NameRegistry.Files.UsedHashes = new List <UInt32>();
var group_dirs = Directory.GetDirectories(sourceFolder);
var file_query = from d in group_dirs
where d != sourceFolder + "\\sporemaster\\"
from f in Directory.GetFileSystemEntries(d)
where !f.EndsWith(".search_index") // < these might appear in group directories if there are indexable files in subdirectories
select f;
var files = file_query.ToList();
files.Add(sourceFolder + "\\sporemaster\\names.txt");
if (progress != null)
{
progress.beginTask(1.0, files.Count);
}
DatabasePackedFile dbf = new DatabasePackedFile();
dbf.Version = new Version(2, 0);
dbf.WriteHeader(output, 0, 0);
var rw4_hash = NameRegistry.Types.toHash("rw4");
uint size, start = (uint)output.Position;
foreach (var f in files)
{
string relativePath = f.Substring(sourceFolder.Length + 1);
bool additionalOutputFiles;
byte[] autoLocale = null;
do
{
additionalOutputFiles = false;
var parts = relativePath.Split(new char[] { '\\' });
if (parts.Length != 2)
{
continue;
}
var group = parts[0];
parts = parts[1].Split(new char[] { '.' }, 2);
var instance = parts[0];
var extension = parts[1];
var index = new DatabaseIndex();
index.GroupId = NameRegistry.Groups.toHash(group);
index.InstanceId = NameRegistry.Files.toHash(instance);
try
{
if (relativePath == "sporemaster\\names.txt")
{
writeNamesFile(output);
}
else if (autoLocale != null)
{
output.Write(autoLocale, 0, autoLocale.Length);
}
else if (extension == "prop.xml")
{
extension = "prop";
writePropFile(group, instance, f, output, out autoLocale);
if (autoLocale.Length != 0)
{
additionalOutputFiles = true;
relativePath = "locale~\\auto_" + group + "_" + instance + ".locale";
}
}
else if (NameRegistry.Types.toHash(extension) == rw4_hash && Directory.Exists(f))
{
writeRW4File(f, output);
}
else
{
writeBinaryFile(f, output);
}
}
catch (Exception e)
{
throw new Exception("Error packing file '" + relativePath + "'.", e);
}
size = (uint)output.Position - start;
index.TypeId = NameRegistry.Types.toHash(extension);
index.Compressed = false;
index.Flags = 1;
index.DecompressedSize = size;
index.CompressedSize = size | 0x80000000;
index.Offset = start;
dbf.Indices.Add(index);
start += size;
} while (additionalOutputFiles);
progress.addProgress(1.0);
}
dbf.WriteIndex(output);
size = (uint)output.Position - start;
output.Seek(0, SeekOrigin.Begin);
dbf.WriteHeader(output, (int)start, (int)size);
output.Close();
if (progress != null)
{
progress.endTask();
}
}
protected override bool AcceptIndex(DatabaseIndex index) => false;
void GetIndexes(
NpgsqlConnection connection,
IReadOnlyList <DatabaseTable> tables,
string tableFilter,
List <uint> constraintIndexes)
{
using (var command = connection.CreateCommand())
{
var getColumnsQuery = @"
SELECT
idxcls.oid AS idx_oid, nspname, cls.relname AS cls_relname, idxcls.relname AS idx_relname, indisunique, indkey, amname,
CASE WHEN indexprs IS NULL THEN NULL ELSE pg_get_expr(indexprs, cls.oid) END AS exprs,
CASE WHEN indpred IS NULL THEN NULL ELSE pg_get_expr(indpred, cls.oid) END AS pred
FROM pg_class AS cls
JOIN pg_namespace AS ns ON ns.oid = cls.relnamespace
JOIN pg_index AS idx ON indrelid = cls.oid
JOIN pg_class AS idxcls ON idxcls.oid = indexrelid
JOIN pg_am AS am ON am.oid = idxcls.relam
WHERE
cls.relkind = 'r' AND
nspname NOT IN ('pg_catalog', 'information_schema')
AND
NOT indisprimary
" + tableFilter;
command.CommandText = getColumnsQuery;
using (var reader = command.ExecuteReader())
{
var tableGroups = reader.Cast <DbDataRecord>().GroupBy(ddr => (
tableSchema: ddr.GetValueOrDefault <string>("nspname"),
tableName: ddr.GetValueOrDefault <string>("cls_relname")
));
foreach (var tableGroup in tableGroups)
{
var tableSchema = tableGroup.Key.tableSchema;
var tableName = tableGroup.Key.tableName;
var table = tables.Single(t => t.Schema == tableSchema && t.Name == tableName);
foreach (var record in tableGroup)
{
// Constraints are detected separately (see GetConstraints), and we don't want their
// supporting indexes to appear independently.
var indexOID = record.GetValueOrDefault <uint>("idx_oid");
if (constraintIndexes.Contains(indexOID))
{
continue;
}
var index = new DatabaseIndex
{
Table = table,
Name = record.GetValueOrDefault <string>("idx_relname"),
IsUnique = record.GetValueOrDefault <bool>("indisunique")
};
var columnIndices = record.GetValueOrDefault <short[]>("indkey");
if (columnIndices.Any(i => i == 0))
{
// Expression index, not supported
_logger.ExpressionIndexSkippedWarning(index.Name, DisplayName(tableSchema, tableName));
continue;
/*
* var expressions = record.GetValueOrDefault<string>("exprs");
* if (expressions == null)
* throw new Exception($"Seen 0 in indkey for index {index.Name} but indexprs is null");
* index[NpgsqlAnnotationNames.IndexExpression] = expressions;
*/
}
else
{
var columns = (List <DatabaseColumn>)table.Columns;
foreach (var i in columnIndices)
{
index.Columns.Add(columns[i - 1]);
}
}
var predicate = record.GetValueOrDefault <string>("pred");
if (predicate != null)
{
index.Filter = predicate;
}
// It's cleaner to always output the index method on the database model,
// even when it's btree (the default);
// NpgsqlAnnotationCodeGenerator can then omit it as by-convention.
// However, because of https://github.com/aspnet/EntityFrameworkCore/issues/11846 we omit
// the annotation from the model entirely.
var indexMethod = record.GetValueOrDefault <string>("amname");
if (indexMethod != "btree")
{
index[NpgsqlAnnotationNames.IndexMethod] = indexMethod;
}
table.Indexes.Add(index);
}
}
}
}
}
