public static Dictionary <TKey, List <TValue> > BucketSort <TKey, TValue>(
this ArraySegment <TValue> inputs,
Func <TValue, bool> validator,
KeySelector <TValue, TKey> keySelector,
DictionaryFactory <TKey, List <TValue> > dictionaryFactory,
ListFactory <TValue> listFactory)
{
var buckets = dictionaryFactory();
for (int x = 0; x < inputs.Count; x++)
{
var input = inputs.Array[x];
if (!validator(input))
{
continue;
}
var keyValue = keySelector(input);
List <TValue> eventsInBucket;
if (!buckets.TryGetValue(keyValue, out eventsInBucket))
{
eventsInBucket = listFactory();
buckets.Add(keyValue, eventsInBucket);
}
eventsInBucket.Add(input);
}
return(buckets);
}
public static Dictionary <TKey, List <TValue> > BucketSort <TKey, TValue>(
this IEnumerable <TValue> inputs,
Func <TValue, bool> validator,
KeySelector <TValue, TKey> keySelector,
DictionaryFactory <TKey, List <TValue> > dictionaryFactory,
ListFactory <TValue> listFactory)
{
var buckets = dictionaryFactory();
foreach (var input in inputs)
{
if (!validator(input))
{
continue;
}
var keyValue = keySelector(input);
List <TValue> eventsInBucket;
if (!buckets.TryGetValue(keyValue, out eventsInBucket))
{
eventsInBucket = listFactory();
buckets.Add(keyValue, eventsInBucket);
}
eventsInBucket.Add(input);
}
return(buckets);
}
private void EnsureDictionaries()
{
try
{
Type[] dictionaryFactoryTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x =>
{
try
{
return x.GetTypes();
}
catch (ReflectionTypeLoadException)
{
return new Type[0];
}
}).Where(type => type.IsSubclassOf(typeof(DictionaryFactory))).Distinct().ToArray();
foreach (Type dictionaryFactoryType in dictionaryFactoryTypes)
{
DictionaryFactory dictionaryFactory =
Activator.CreateInstance(dictionaryFactoryType) as DictionaryFactory;
dictionaryFactory?.EnsureDictionaries();
}
}
catch(Exception exception)
{
Log.Error(exception, "Not able to ensure dictionaries");
}
}
public void HasRoleはInitializeで指定されたテストケースにパラメタセクションがなければfalseを返す()
{
// setup
Sheet sheet = TempActors.Book.GetSheet("HasRole");
DictionaryFactory factory = GetDictionaryFactory(sheet.GetCase("ロールなし"));
// expect
Assert.IsFalse(factory.HasRole <object>(null));
}
public void HasRoleは引数のクラスがDictionaryでなければfalseを返す()
{
// setup
Sheet sheet = TempActors.Book.GetSheet("HasRole");
DictionaryFactory factory = GetDictionaryFactory(sheet.GetCase("ロールあり"));
// expect
Assert.IsFalse(factory.HasRole <object>(null));
}
public void HasRoleは引数のクラスがDictionaryでありかつInitializeで指定されたテストケースにパラメタセクションがあればtrueを返す()
{
// setup
Sheet sheet = TempActors.Book.GetSheet("HasRole");
DictionaryFactory factory = GetDictionaryFactory(sheet.GetCase("ロールあり"));
// expect
Assert.IsTrue(factory.HasRole <Dictionary <string, object> >(null));
}
public static SortedValueDictionary <object, int> CreateVideosTimeAnalysisDictionary(
User i_AnalysisUser,
eTimeSelector i_TimeFrame)
{
return(DictionaryFactory.CreateTimeAnalysisDictionary(
i_AnalysisUser,
i_TimeFrame,
i_EType => Post.eType.video == i_EType));
}
public Dictionary <int, T> Build <T>()
{
var factory = new DictionaryFactory <int, T>(size);
var list = factory.Create();
var initializer = new IntKeyDictionaryInitializer <T>(default(T), size);
initializer.Initialize(list);
return(list);
}
public override void Execute(Database database, IIssueCollector issueCollector, IProviderCollection providers)
{
this._nodeProps = DictionaryFactory.CreateTableID <NodeProperties>();
this._foundCycles = new List <List <Table> >();
this._stack = new Stack <Table>();
this._index = 0;
foreach (var table in database.Tables)
{
if (!this._nodeProps.ContainsKey(table))
{
this.Tarjan(table);
}
}
foreach (var cycle in this._foundCycles)
{
var canInsert = false;
var foundTables = new Dictionary <Table, List <ForeignKey> >();
foreach (var table in cycle)
{
var fksValues = table.ForeignKeys.Where(p => cycle.Contains(p.PKTable)).ToList();
foundTables.Add(table, fksValues);
foreach (var fkValue in fksValues)
{
if (fkValue.ColumnPairs.All(f => f.FKColumn.IsNullable) ||
(fkValue.Deferrability == Deferrability.Deferrable && fkValue.InitialMode == InitialMode.InitiallyDeferred))
{
canInsert = true;
}
}
}
var issue = new Issue(this, this.DefaultSeverity.Value);
issue.Name = "Cycle Dependency Between Tables";
issue.Context = IssueContext.Create(cycle);
string tableList = String.Join(", ", cycle.Select(c => c.TableName));
if (tableList.Length > 20)
{
tableList = tableList.Substring(0, 20) + "...";
}
issue.Description = new Description("Cycle dependency between {0} tables: {1}", cycle.Count, tableList);
var str = new StringBuilder();
// Delete rules is no longer included in the check because of complex cycles
if (!canInsert)
{
str.Append("There is a cycle dependency, where the referential constraints could yield problems.");
str.Append("\n- Deferability and initially-deferred configurations could complicate insert, update and delete statements.");
issue.ExtendedDescription = new Description("{0}\n\nThe cycle contains the tables:\n\n{1}", str.ToString(), GetTable(foundTables));
}
else
{
issue.Severity = CycleWithoutDeferabilityProblems.Value;
issue.ExtendedDescription = new Description("There is a cyclic dependency, but there are no deferability constraints that could yield problems. Consider if the cyclic dependency is needed.\n\nThe cycle contains the tables:\n\n{0}", GetTable(foundTables));
}
issueCollector.ReportIssue(issue);
}
}
public void ToDictionary()
{
var diccionario = this.HashTableFactory.ToDictionary <int, string>();
foreach (var valor in diccionario)
{
Assert.IsTrue(DictionaryFactory.ContainsKey(valor.Key));
Assert.AreSame(valor.Value, DictionaryFactory[valor.Key]);
}
}
public override void Execute(DataTable table, IIssueCollector issueCollector, IProviderCollection providers)
{
if (table.Cardinality < MinRows.Value)
{
return;
}
var checkedColumns = table.QueryableColumns;
if (checkedColumns.Count == 0)
{
return;
}
var columnNullCount = DictionaryFactory.CreateColumnID <int>();
foreach (var col in checkedColumns)
{
columnNullCount[col] = 0;
}
int rowCount = 0;
using (var rowEnumerable = table.GetTableRowEnumerable())
foreach (var row in rowEnumerable)
{
rowCount++;
foreach (var col in checkedColumns)
{
var val = row[col.ColumnName];
if (val is DBNull)
{
columnNullCount[col] += 1;
}
}
}
var maxnullCount = this.MaxPercentageNull.Value * rowCount / 100f;
var columnsWithTooManyNulls = from cp in columnNullCount
where cp.Value > maxnullCount
select cp;
foreach (var columnWithTooManyNulls in columnsWithTooManyNulls)
{
var percentNull = Math.Round(columnWithTooManyNulls.Value * 100f / rowCount, 1);
issueCollector.ReportIssue(new Issue(this, this.Severity)
{
Name = "Column Containing Too Many Nulls",
Context = new ColumnContext(columnWithTooManyNulls.Key),
Description = new Description("Column '{0}' has {1} percent nulls", columnWithTooManyNulls.Key, percentNull)
});
}
}
public void CompareListTest225()
{
List <Card> list;
Dictionary <string, int> dictionary;
List <Card> list1;
Card[] cards = new Card[1];
list = new List <Card>((IEnumerable <Card>)cards);
dictionary = DictionaryFactory.Create(0, "", 0);
list1 = this.CompareListTest(list, dictionary);
Assert.IsNull((object)list1);
}
private string createAggregatedFileAndReturnItsDirectory(string filePath)
{
string[] rawFileContent = FileReaderWriter.readFromFile(filePath);
var countryPersonPair = DictionaryFactory.createCountryPersonDictionary(rawFileContent);
var sortedDict = DictionaryFactory.sortCountriesByAverageScore(countryPersonPair);
string aggregatedData = DataAggregator.collectAndSortData(countryPersonPair, sortedDict);
string aggregatedDataFilePath = FileReaderWriter.writeAggregatedDataToFile(aggregatedData);
return(aggregatedDataFilePath);
}
public void It_Should_Find_The_Parent_Loop()
{
TemplateContext ctx = new TemplateContext();
//ctx.Define("outer", new LiquidCollection(new List<ILiquidValue> { new LiquidNumeric(1), new LiquidNumeric(1), new LiquidNumeric(1) }));
ctx.DefineLocalVariable("outer", DictionaryFactory.CreateArrayFromJson("[[1, 1, 1], [1, 1, 1]]"));
var template = LiquidTemplate.Create("Result :{% for inner in outer %}{% for k in inner %} {{ forloop.parentloop.index }}.{{ forloop.index }}{% endfor %}{% endfor %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
// Assert
Assert.Equal("Result : 1.1 1.2 1.3 2.1 2.2 2.3", result);
}
public T Create()
{
ICollectionFactory <T> factory = null;
if (typeof(IDictionary).IsAssignableFrom(typeof(T)))
{
factory = new DictionaryFactory <T>() as ICollectionFactory <T>;
}
else if (typeof(IList).IsAssignableFrom(typeof(T)))
{
factory = new ListFactory <T>() as ICollectionFactory <T>;
}
return(factory.Create());
}
public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags, int startId)
{
if (intent.Action.Equals(PlaybackConsts.Start))
{
var notification =
new Notification.Builder(this)
.SetContentTitle(Resources.GetString(Resource.String.ApplicationName))
.SetContentText("HELLO WORLD")
.SetOngoing(true)
.Build();
StartForeground(SERVICE_RUNNING_NOTIFICATION_ID, notification);
}
if (intent.Action.Equals(PlaybackConsts.Start))
{
var uri = Android.Net.Uri.Parse(intent.GetStringExtra("uri"));
var content = MiscellaneousHelper.GetTextFromStream(ContentResolver.OpenInputStream(uri));
Dictionary = DictionaryFactory.Get(content);
Playing = true;
Task.Factory.StartNew(async() =>
{
await PlayDictionary();
});
}
if (intent.Action.Equals(PlaybackConsts.PlayPause))
{
bool isChecked = intent.GetBooleanExtra("isChecked", false);
PlayPause(isChecked);
}
if (intent.Action.Equals(PlaybackConsts.NextEntry))
{
NextEntry();
}
if (intent.Action.Equals(PlaybackConsts.PrevEntry))
{
PrevEntry();
}
if (intent.Action.Equals(PlaybackConsts.Stop))
{
Task.Factory.StartNew(async() =>
{
await Stop();
});
StopForeground(true);
StopSelf();
}
return(StartCommandResult.Sticky);
}
public void CompareListTest615()
{
Card card;
List <Card> list;
Dictionary <string, int> dictionary;
List <Card> list1;
card = CardFactory.Create("\0", 0);
Card[] cards = new Card[1];
cards[0] = card;
list = new List <Card>((IEnumerable <Card>)cards);
dictionary = DictionaryFactory.Create(0, "\0", 0);
list1 = this.CompareListTest(list, dictionary);
Assert.IsNotNull((object)list1);
Assert.AreEqual <int>(4, list1.Capacity);
Assert.AreEqual <int>(1, list1.Count);
}
/// <summary>
/// Get user information string
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
static string GetUserInfo(string userName)
{
if (UserNames == null)
{
DictionaryFactory df = new DictionaryFactory();
UserNames = DictionaryMx.Get("UserName");
if (UserNames == null)
{
UserNames = new DictionaryMx();
}
}
userName = UserInfo.NormalizeUserName(userName);
string userInfo = UserNames.LookupDefinition(userName);
return(userInfo);
}
public void It_Should_Cycle_Through_Groups(String input, String assigns, String expected)
{
// Arrange
ITemplateContext ctx = new TemplateContext().WithAllFilters();
foreach (var tuple in DictionaryFactory.CreateStringMapFromJson(assigns))
{
ctx.DefineLocalVariable(tuple.Item1, tuple.Item2);
}
var template = LiquidTemplate.Create(input);
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
// Assert
Assert.Equal(expected, result.Trim());
}
public void It_Should_Render_A_Table_Row_From_A_String()
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("numbers", DictionaryFactory.CreateArrayFromJson("[1, 2, 3, 4, 5, 6]"));
var template = LiquidTemplate.Create(@"{% tablerow n in ""Test"" cols:2%}ITER{{n}}{% endtablerow %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
String expected =
"<tr class=\"row1\">\r\n<td class=\"col1\">ITERTest</td></tr>";
// Act
// Assert
Assert.That(result, Is.StringContaining(expected));
}
public void It_Should_Render_A_Table_Row()
{
// Arrange
TemplateContext ctx = new TemplateContext();
ctx.DefineLocalVariable("numbers", DictionaryFactory.CreateArrayFromJson("[1, 2, 3, 4, 5, 6]"));
var template = LiquidTemplate.Create(@"{% tablerow n in numbers cols:2%}ITER{{n}}{% endtablerow %}");
// Act
String result = template.LiquidTemplate.Render(ctx).Result;
Logger.Log(result);
String expected =
"<tr class=\"row1\">\r\n" +
@"<td class=""col1"">ITER1</td><td class=""col2"">ITER2</td></tr>" + "\r\n" +
@"<tr class=""row2""><td class=""col1"">ITER3</td><td class=""col2"">ITER4</td></tr>" + "\r\n" +
@"<tr class=""row3""><td class=""col1"">ITER5</td><td class=""col2"">ITER6</td></tr>";
// Act
// Assert
Assert.Contains(expected, result);
}
public override void Execute(Database database, IProviderCollection providers)
{
double damping = 0.85;
DatabaseDictionary <TableID, DoubleWrapper> ranks = DictionaryFactory.CreateTableID <DoubleWrapper>();
DatabaseDictionary <TableID, DoubleWrapper> rankCalculator = DictionaryFactory.CreateTableID <DoubleWrapper>();
DatabaseDictionary <TableID, Table[]> neighborMatrix = DictionaryFactory.CreateTableID <Table[]>();
var initialRank = 1f / database.Tables.Count;
foreach (var table in database.Tables)
{
ranks.Add(table, new DoubleWrapper {
Value = 1
});
var referencedBy = new List <Table>();
foreach (var fkTable in table.ReferencedBy)
{
foreach (var foreignKey in fkTable.ForeignKeys)
{
if (foreignKey.PKTable.Equals(table))
{
referencedBy.Add(fkTable);
}
}
}
neighborMatrix.Add(table, referencedBy.ToArray());
}
foreach (var tableID in ranks.Keys)
{
rankCalculator[tableID] = new DoubleWrapper {
Value = 0
};
ranks[tableID] = new DoubleWrapper {
Value = 0
};
}
for (int i = 0; i < 100; i++)
{
double error = 0;
foreach (var tableID in ranks.Keys)
{
double value = 0;
var references = neighborMatrix[tableID];
foreach (var reference in references)
{
var referenceRank = ranks[reference];
value += referenceRank.Value / reference.ForeignKeys.Count;
}
double newRank;
rankCalculator[tableID].Value = newRank = value * damping + initialRank * (1 - damping);
error += Math.Abs(ranks[tableID].Value - newRank);
}
{
var tmp = rankCalculator;
rankCalculator = ranks;
ranks = tmp;
}
if (error < 0.001)
{
break;
}
}
double sum = 0;
foreach (var key in ranks.Keys)
{
sum += ranks[key].Value;
}
foreach (var key in ranks.Keys)
{
_ranks[key] = ranks[key].Value / sum * 100;
}
}
public override void Finalize(Model.Database database, IProviderCollection providers)
{
var informationContent = providers.GetProvider <InformationContent>();
var fks = database.Tables.SelectMany(t => t.ForeignKeys);
DatabaseDictionary <TableID, List <JoinEdge> > dbJoinEdges = DictionaryFactory.CreateTableID <List <JoinEdge> >();
DatabaseDictionary <TableID, double> tableTotalEntropyTransfer = DictionaryFactory.CreateTableID <double>();
foreach (var tbl in database.Tables)
{
dbJoinEdges[tbl] = new List <JoinEdge>(4);
tableTotalEntropyTransfer[tbl] = 0;
}
foreach (var foreignKey in fks)
{
var pkColumns = (from cp in foreignKey.ColumnPairs
select cp.PKColumn).ToArray();
var fkColumns = (from cp in foreignKey.ColumnPairs
select cp.FKColumn).ToArray();
double fkEdgeEntropy;
if (foreignKey.IsSingleColumn)
{
fkEdgeEntropy = informationContent[foreignKey.FKColumn];
}
else
{
fkEdgeEntropy = informationContent.GetMultiColumnEntropy((DataTable)foreignKey.FKTable, fkColumns);
}
var pkEdgeEntropy = Math.Log(Math.Max(foreignKey.PKTable.Cardinality, 1), 2); // Primary key guarantees uniqueness across pkcolumns, hence entropy equals log of cardinality.
dbJoinEdges[foreignKey.PKTable].Add(new JoinEdge {
Table = foreignKey.FKTable, Columns = fkColumns, EdgeEntropy = fkEdgeEntropy
});
dbJoinEdges[foreignKey.FKTable].Add(new JoinEdge {
Table = foreignKey.PKTable, Columns = pkColumns, EdgeEntropy = pkEdgeEntropy
});
tableTotalEntropyTransfer[foreignKey.PKTable] += pkEdgeEntropy;
tableTotalEntropyTransfer[foreignKey.FKTable] += fkEdgeEntropy;
}
DatabaseDictionary <TableID, DatabaseDictionary <TableID, double> > pmatrix = DictionaryFactory.CreateTableID <DatabaseDictionary <TableID, double> >();
foreach (var tbl in database.Tables)
{
pmatrix[tbl] = DictionaryFactory.CreateTableID <double>();
}
foreach (var toTable in database.Tables)
{
var joinEdges = dbJoinEdges[toTable];
foreach (var joinEdge in joinEdges)
{
var fromTable = joinEdge.Table;
var columnsEntropy = joinEdge.EdgeEntropy;
var tableInformationContent = informationContent[fromTable];
var tableTotalTransfer = tableTotalEntropyTransfer[fromTable];
var todic = pmatrix[toTable];
if (!todic.ContainsKey(fromTable))
{
todic[fromTable] = 0;
}
if (tableInformationContent + tableTotalTransfer > 0)
{
todic[fromTable] += columnsEntropy / (tableInformationContent + tableTotalTransfer);
}
}
var toTableRow = pmatrix[toTable];
}
foreach (var keyRow in pmatrix.Keys)
{
double selfLoopValue = 1d;
foreach (var keyColumn in pmatrix.Keys)
{
var row = pmatrix[keyColumn];
if (row.ContainsKey(keyRow))
{
selfLoopValue -= row[keyRow];
}
}
if (selfLoopValue < 0)
{
}
pmatrix[keyRow][keyRow] = selfLoopValue;
}
DatabaseDictionary <TableID, double> importanceVector = DictionaryFactory.CreateTableID <double>();
DatabaseDictionary <TableID, double> calculateVector = DictionaryFactory.CreateTableID <double>();
foreach (var table in database.Tables)
{
importanceVector[table] = Math.Max(informationContent[table], 0);
}
for (int i = 0; i < 100; i++)
{
foreach (var table in importanceVector.Keys)
{
double newRank = 0;
var fromTables = pmatrix[table];
foreach (var fromTable in fromTables)
{
var fromRank = importanceVector[fromTable.Key];
newRank += fromRank * fromTable.Value;
}
calculateVector[table] = newRank;
}
{
var tmp = calculateVector;
calculateVector = importanceVector;
importanceVector = tmp;
}
}
var totalEntropy = importanceVector.Values.Sum();
foreach (var k in importanceVector.Keys)
{
if (importanceVector[k] < 0)
{
}
if (totalEntropy == 0)
{
importanceVector[k] = 100f / database.Tables.Count;
}
else
{
importanceVector[k] *= 100f / totalEntropy;
}
}
this._importanceVector = importanceVector;
}
/** <inheritdoc /> */
public IDictionary ReadDictionary(DictionaryFactory factory)
{
return(Read(r => BinaryUtils.ReadDictionary(r, factory), BinaryUtils.TypeDictionary));
}
/** <inheritdoc /> */
public IDictionary ReadDictionary(string fieldName, DictionaryFactory factory)
{
return(ReadField(fieldName, r => BinaryUtils.ReadDictionary(r, factory), BinaryUtils.TypeDictionary));
}
public static Database DatabaseFactory(Extractor extractor, IEnumerable <DBLint.DataAccess.DBObjects.Schema> selectedSchemas, IEnumerable <DBLint.DataAccess.DBObjects.TableID> ignoredTables)
{
var database = new Database(extractor.DatabaseName, extractor.Database);
var ignoredDictionary = DictionaryFactory.CreateTableID <TableID>();
foreach (var ignoredTable in ignoredTables)
{
var tblid = new TableID(extractor.DatabaseName, ignoredTable.SchemaName, ignoredTable.TableName);
ignoredDictionary.Add(tblid, tblid);
}
using (var db = database)
{
var dbSchemas = extractor.Database.GetSchemas();
foreach (var dbSchema in dbSchemas)
{
using (var schema = new Schema(db.DatabaseName, dbSchema.SchemaName))
{
if (!selectedSchemas.Any(p => p.Equals(dbSchema)))
{
continue;
}
schema.Database = db;
db._schemas.Add(schema);
#region Table and table columns
var dbTables = extractor.Database.GetTables(schema.SchemaName);
var tables = from dbTable in dbTables
orderby dbTable.TableName
select dbTable;
foreach (var dbTable in tables)
{
var table = new DataTable(db.DatabaseName, schema.SchemaName, dbTable.TableName, extractor.Database);
if (ignoredDictionary.ContainsKey(table))
{
database.IgnoredTables.Add(table);
continue;
}
schema._tables.Add(table);
db.tableDictionary.Add(table, table);
table.Database = db;
table.Schema = schema;
}
var dbColumns = extractor.Database.GetColumns(schema.SchemaName);
var columnID = new ColumnID(extractor.DatabaseName, schema.SchemaName, null, null);
foreach (var dbColumn in dbColumns)
{
columnID.TableName = dbColumn.TableName;
columnID.ColumnName = dbColumn.ColumnName;
if (db.tableDictionary.ContainsKey(columnID))
{
var column = new Column(db.DatabaseName, schema.SchemaName, dbColumn.TableName, dbColumn.ColumnName);
var table = db.tableDictionary[column];
table._columns.Add(column);
column.DataType = dbColumn.DataType;
column.DefaultValue = dbColumn.DefaultValue;
column.OrdinalPosition = dbColumn.OrdinalPosition;
column.CharacterMaxLength = dbColumn.CharacterMaxLength;
column.IsNullable = dbColumn.IsNullable;
column.NumericPrecision = dbColumn.NumericPrecision;
column.NumericScale = dbColumn.NumericScale;
column.Table = table;
column.Schema = schema;
column.Database = db;
column.IsSequence = dbColumn.IsSequence;
column.IsDefaultValueAFunction = dbColumn.DefaultIsFunction;
}
}
#endregion
#region Views and view columns
var dbViews = extractor.Database.GetViews(schema.SchemaName);
var views = from dbView in dbViews
orderby dbView.ViewName
select dbView;
foreach (var dbView in views)
{
var view = new View(db.DatabaseName, schema.SchemaName, dbView.ViewName);
schema._views.Add(view);
db.viewDictionary.Add(view, view);
view.Database = db;
view.Schema = schema;
}
var dbViewColumns = extractor.Database.GetViewColumns(schema.SchemaName);
var viewColumnID = new ViewColumnID(extractor.DatabaseName, schema.SchemaName, null, null);
foreach (var dbViewColumn in dbViewColumns)
{
viewColumnID.ViewName = dbViewColumn.ViewName;
viewColumnID.ColumnName = dbViewColumn.ColumnName;
if (db.viewDictionary.ContainsKey(viewColumnID))
{
var viewColumn = new ViewColumn(db.DatabaseName, schema.SchemaName, dbViewColumn.ViewName, dbViewColumn.ColumnName);
var view = db.viewDictionary[viewColumn];
view._columns.Add(viewColumn);
viewColumn.Database = db;
viewColumn.Schema = schema;
viewColumn.View = view;
viewColumn.DataType = dbViewColumn.DataType;
viewColumn.DefaultValue = dbViewColumn.DefaultValue;
viewColumn.OrdinalPosition = dbViewColumn.OrdinalPosition;
viewColumn.CharacterMaxLength = dbViewColumn.CharacterMaxLength;
viewColumn.IsNullable = dbViewColumn.IsNullable;
viewColumn.NumericPrecision = dbViewColumn.NumericPrecision;
viewColumn.NumericScale = dbViewColumn.NumericScale;
viewColumn.Privileges = dbViewColumn.Privileges;
}
}
#endregion
// Adding functions
var functions = extractor.Database.GetFunctions(schema.SchemaName);
foreach (var function in functions)
{
var f = new Function(
database.DatabaseName,
function.SchemaName,
function.RoutineName);
f.Database = database;
f.Schema = schema;
schema._functions.Add(f);
}
var fParameters = extractor.Database.GetFunctionsParameters(schema.SchemaName);
foreach (var fParameter in fParameters)
{
var fp = new Parameter(database.DatabaseName, fParameter.SchemaName, fParameter.RoutineName, fParameter.ParameterName);
fp.Database = schema.Database;
fp.Schema = schema;
fp.DataType = fParameter.DataType;
fp.Direction = fParameter.Direction;
fp.CharacterMaxLength = fParameter.CharacterMaxLength;
fp.NumericPrecision = fParameter.NumericPrecision;
fp.NumericScale = fParameter.NumericScale;
fp.OrdinalPosition = fParameter.OrdinalPosition;
var tmpF = schema._functions.Where(f => f.FunctionName.Equals(fp.RoutineName)).FirstOrDefault();
if (tmpF != null)
{
fp.Routine = tmpF;
tmpF._parameters.Add(fp);
}
}
// Adding stored procedures
var storedProcedures = extractor.Database.GetStoredProcedures(schema.SchemaName);
foreach (var storedProcedure in storedProcedures)
{
var sp = new StoredProcedure(
database.DatabaseName,
storedProcedure.SchemaName,
storedProcedure.RoutineName);
sp.Database = database;
sp.Schema = schema;
schema._storedProcedures.Add(sp);
}
var parameters = extractor.Database.GetStoredProceduresParameters(schema.SchemaName);
foreach (var parameter in parameters)
{
var p = new Parameter(database.DatabaseName, parameter.SchemaName, parameter.RoutineName, parameter.ParameterName);
p.Database = schema.Database;
p.Schema = schema;
p.DataType = parameter.DataType;
p.Direction = parameter.Direction;
p.CharacterMaxLength = parameter.CharacterMaxLength;
p.NumericPrecision = parameter.NumericPrecision;
p.NumericScale = parameter.NumericScale;
p.OrdinalPosition = parameter.OrdinalPosition;
var tmpSp = schema._storedProcedures.Where(sp => sp.StoredProcedureName.Equals(p.RoutineName)).FirstOrDefault();
if (tmpSp != null)
{
p.Routine = tmpSp;
tmpSp._parameters.Add(p);
}
}
}
}
}
AddForeignKeys(extractor, database);
AddPrimaryKeys(extractor, database);
AddIndices(extractor, database);
AddUniqueConstraints(extractor, database);
foreach (var tbl in database.Tables)
{
tbl.Dispose();
}
foreach (var view in database.Views)
{
view.Dispose();
}
AddCardinalities(database.tableDictionary, extractor, selectedSchemas);
database.Escaper = Escaper.GetEscaper(extractor.Database.DBMS);
database.DBMS = extractor.Database.DBMS;
return(database);
}
public override void Execute(DataTable table, IIssueCollector issueCollector, IProviderCollection providers)
{
var dataTypes = new[] { DataType.CHAR, DataType.NCHAR, DataType.NVARCHAR, DataType.VARCHAR };
var informationContent = providers.GetProvider <InformationContent>();
var columnsToCheck = (from c in table.Columns
where dataTypes.Contains(c.DataType) && informationContent[c] < 3 // Avoid checking columns with more than 8 unique values
select c).ToArray();
if (columnsToCheck.Length == 0)
{
return;
}
var columnNotBooleanCount = DictionaryFactory.CreateColumnID <int>();
foreach (var col in columnsToCheck)
{
columnNotBooleanCount[col] = 0;
}
int rowCount = 0;
using (var rowEnumerable = table.GetTableRowEnumerable())
foreach (var row in rowEnumerable)
{
rowCount++;
foreach (var column in columnsToCheck)
{
var value = row[column.ColumnName];
if (value is DBNull || !Classifier.IsBool(value.ToString()))
{
columnNotBooleanCount[column] += 1;
}
}
// Foreach 128th row, check that all columns are likely to be boolean
if ((rowCount & 127) == 0)
{
var allowedDirtiness = rowCount * DirtinessFactor.Value / 100f;
columnsToCheck = columnsToCheck.Where(c => columnNotBooleanCount[c] < allowedDirtiness).ToArray();
if (columnsToCheck.Length == 0)
{
return;
}
}
}
foreach (var column in columnsToCheck)
{
var allowedDirtiness = rowCount * DirtinessFactor.Value / 100f;
if (columnNotBooleanCount[column] < allowedDirtiness)
{
issueCollector.ReportIssue(new Issue(this, this.Severity)
{
Name = "Text Column Used for Boolean Values",
Context = new ColumnContext(column),
Description = new Description("The column '{0}' contains boolean values. Consider using another data type", column),
Severity = this.Severity
});
}
}
}
public override void Execute(Database database, IIssueCollector issueCollector, IProviderCollection providers)
{
foreach (var schema in database.Schemas)
{
if (!schema.Tables.Any(t => t.ForeignKeys.Count > 0))
{
Issue s = new Issue(this, Severity.Critical);
s.Name = "No Foreign Keys";
s.Description = new Description("The schema '{0}' has no foreign keys", schema.SchemaName);
s.Context = new SchemaContext(schema);
issueCollector.ReportIssue(s);
continue;
}
DatabaseDictionary <TableID, Table> seenTables = DictionaryFactory.CreateTableID <Table>();
DatabaseDictionary <TableID, Table> notSeen = DictionaryFactory.CreateTableID <Table>();
foreach (var t in schema.Tables)
{
notSeen.Add(t, t);
}
List <List <Table> > clusters = new List <List <Table> >();
while (notSeen.Count > 0)
{
var table = notSeen.First().Value;
var cluster = new List <Table>(schema.Tables.Count);
BrowseTables(table, seenTables, notSeen, cluster);
clusters.Add(cluster);
}
foreach (var cluster in clusters)
{
if (cluster.Count == 1)
{
Issue issue = new Issue(this, this.DefaultSeverity.Value)
{
Context = new TableContext(cluster[0]),
Name = "Table Island",
Description = new Description("Table {0} does not reference anything and is not referenced by anything", cluster[0]),
};
issueCollector.ReportIssue(issue);
}
else
{
if (cluster.Count > schema.Tables.Count * this.MaxFractionTables.Value / 100f || schema.Tables.Count > this.MaxTableIslandCount.Value)
{
continue;
}
string tableList = String.Join(", ", cluster.Select(c => c.TableName));
if (tableList.Length > 20)
{
tableList = tableList.Substring(0, 20) + "...";
}
Issue issue = new Issue(this, LargeTableIslandSeverity.Value)
{
Context = IssueContext.Create(cluster),
Name = "Table Island",
Description = new Description("There is a table island containing {0} tables: {1}", cluster.Count, tableList),
ExtendedDescription = new Description("Tables: {0}", cluster),
};
issueCollector.ReportIssue(issue);
}
}
}
}
internal List <string> GetLemmas(string text, string tag)
{
return((DictionaryFactory.GetDictionary().GetLemmas(text, tag) ?? new string[0]).ToList());
}
public static SortedValueDictionary <object, int> CreatePhotosBiggestFansAnalysisDictionary(
User i_AnalysisUser,
eTimeSelector i_TimeFrame)
{
return(DictionaryFactory.CreateBiggestFanAnalysisDictionary(i_AnalysisUser, i_TimeFrame, i_EType => Post.eType.photo == i_EType));
}
