public static bool SaveImage(DatabaseKey databaseKey, string name, BitmapSource image)
{
try
{
if (!Cache.SaveCheck(databaseKey, name, ImageExtensionName, out string filename))
{
return(false);
}
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
using (Diagnostics.PotentialExceptionRegion)
{
using (var stream = File.Create(filename))
encoder.Save(stream);
}
return(true);
}
catch (Exception ex)
{
Trace.WriteLine(
$"Save image cache '{name}' for version '{databaseKey.Version}' failed: {ex.ToString()}");
return(false);
}
}
private static DbCommand readCommandRelatedType <T>(DatabaseKey fromTypeKey)
{
Map map = Maps.Map <T>();
DatabaseKey toTypeKey = map.ForeignKey;
return(readCommand(map.ReadCommandTextIsSql, map.ReadCommandText, DatabaseKey.Relate(fromTypeKey, toTypeKey)));
}
public async Task ShowForeignKey1To1(string table, DatabaseKey key)
{
var definition = definitionProvider.GetDefinition(table);
if (definition == null)
{
throw new UnsupportedTableException(table);
}
if (definition.RecordMode != RecordMode.SingleRow)
{
throw new Exception("TemplateMode and MultiRow not supported, because we require 1 - 1 relation!");
}
var fakeSolutionItem = new DatabaseTableSolutionItem(definition.Id, definition.IgnoreEquality);
var openIsNoSaveMode = await CheckIfItemIsOpened(fakeSolutionItem, definition);
var viewModel = containerProvider.Resolve <OneToOneForeignKeyViewModel>(
(typeof(DatabaseKey), key),
(typeof(bool), openIsNoSaveMode),
(typeof(DatabaseTableDefinitionJson), definition));
await windowManager.ShowDialog(viewModel);
}
public static async Task AnalyseTables_GivenTableWithPrimaryKey_ProducesNoMessages()
{
var rule = new CandidateKeyMissingRule(RuleLevel.Error);
var testColumn = new DatabaseColumn(
"test_column",
Mock.Of <IDbType>(),
false,
null,
null
);
var testPrimaryKey = new DatabaseKey(
Option <Identifier> .Some("test_primary_key"),
DatabaseKeyType.Primary,
new[] { testColumn },
true
);
var table = new RelationalDatabaseTable(
"test",
new List <IDatabaseColumn>(),
testPrimaryKey,
Array.Empty <IDatabaseKey>(),
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseIndex>(),
Array.Empty <IDatabaseCheckConstraint>(),
Array.Empty <IDatabaseTrigger>()
);
var tables = new[] { table };
var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);
Assert.That(hasMessages, Is.False);
}
private static DbCommand readCommandType <T>(object[] parameterValues)
{
Map map = Maps.Map <T>();
DatabaseKey typeKey = map.PrimaryKey;
return(readCommand(map.ReadCommandTextIsSql, map.ReadCommandText, typeKey, map.ReadUnboundParameterNames(), parameterValues));
}
public DatabaseEntityRemovedByIndexHistoryAction(DatabaseEntity entity, int index, ViewModelBase viewModel)
{
this.entity = entity;
this.index = index;
this.viewModel = viewModel;
actualKey = entity.GenerateKey(viewModel.TableDefinition);
}
public static async Task AnalyseTables_GivenTableWithDisabledUniqueKey_ProducesMessages()
{
var rule = new DisabledObjectsRule(RuleLevel.Error);
var testColumn = new DatabaseColumn(
"test_column",
Mock.Of <IDbType>(),
false,
null,
null
);
var testUniqueKey = new DatabaseKey(
Option <Identifier> .Some("test_unique_key"),
DatabaseKeyType.Unique,
new[] { testColumn },
false
);
var table = new RelationalDatabaseTable(
"test",
new List <IDatabaseColumn>(),
null,
new[] { testUniqueKey },
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseIndex>(),
Array.Empty <IDatabaseCheckConstraint>(),
Array.Empty <IDatabaseTrigger>()
);
var tables = new[] { table };
var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);
Assert.That(hasMessages, Is.True);
}
public DatabaseExecuteDeleteHistoryAction(MultiRowDbTableEditorViewModel viewModel,
DatabaseEntity entity)
{
this.viewModel = viewModel;
this.entity = entity;
actualKey = entity.GenerateKey(viewModel.TableDefinition);
}
public C Read <T, C, I>(object[] parameterValues = null)
where T : class, I, new()
where C : ICollection <I>, new()
{
DatabaseKey key = primaryKey;
using (IDataReader idr = db.ExecuteReader(readCommandRelatedType <T>(primaryKey))) {
return(readObjects <T, C, I>(idr));
}
}
public DatabaseEntityConditionsChangedHistoryAction(DatabaseEntity entity,
IReadOnlyList <ICondition>?oldConditions,
IReadOnlyList <ICondition>?newConditions,
ViewModelBase viewModel)
{
this.entity = entity;
this.oldConditions = oldConditions;
this.newConditions = newConditions;
this.viewModel = viewModel;
this.actualKey = entity.GenerateKey(viewModel.TableDefinition);
}
public static void Columns_PropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new DatabaseKey(keyName, keyType, columns, true);
Assert.That(key.Columns, Is.EqualTo(columns));
}
public static void Name_PropertyGet_EqualsCtorArg()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Primary;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
var key = new DatabaseKey(keyName, keyType, columns, true);
Assert.That(key.Name.UnwrapSome(), Is.EqualTo(keyName));
}
public static void IsEnabled_WhenGivenFalseInCtor_ReturnsFalse()
{
Identifier keyName = "test_key";
const DatabaseKeyType keyType = DatabaseKeyType.Foreign;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = false;
var key = new DatabaseKey(keyName, keyType, columns, enabled);
Assert.That(key.IsEnabled, Is.EqualTo(enabled));
}
public C ReadRelated <T, C, I>(object keyValue = null)
where T : class, I, new()
where C : ICollection <I>, new()
{
DatabaseKey key = primaryKey;
if (null != keyValue)
{
key = new DatabaseKey(key.Name, keyValue);
}
using (IDataReader idr = db.ExecuteReader(readCommandRelatedType <T>(key))) {
return(readObjects <T, C, I>(idr));
}
}
public static async Task AnalyseTables_GivenTableWithDisabledForeignKey_ProducesMessages()
{
var rule = new DisabledObjectsRule(RuleLevel.Error);
var testColumn = new DatabaseColumn(
"test_column",
Mock.Of <IDbType>(),
false,
null,
null
);
var testForeignKey = new DatabaseKey(
Option <Identifier> .Some("test_foreign_key"),
DatabaseKeyType.Foreign,
new[] { testColumn },
false
);
var testPrimaryKey = new DatabaseKey(
Option <Identifier> .Some("test_primary_key"),
DatabaseKeyType.Primary,
new[] { testColumn },
false
);
var testRelationalKey = new DatabaseRelationalKey(
"child_table",
testForeignKey,
"parent_table",
testPrimaryKey,
ReferentialAction.Cascade,
ReferentialAction.Cascade
);
var table = new RelationalDatabaseTable(
"test",
new List <IDatabaseColumn>(),
null,
Array.Empty <IDatabaseKey>(),
new[] { testRelationalKey },
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseIndex>(),
Array.Empty <IDatabaseCheckConstraint>(),
Array.Empty <IDatabaseTrigger>()
);
var tables = new[] { table };
var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);
Assert.That(hasMessages, Is.True);
}
public static void ToString_WhenInvoked_ReturnsExpectedValues(DatabaseKeyType keyType, string name, string expectedResult)
{
var keyName = !name.IsNullOrWhiteSpace()
? Option <Identifier> .Some(Identifier.CreateQualifiedIdentifier(name))
: Option <Identifier> .None;
var column = Mock.Of <IDatabaseColumn>();
var columns = new[] { column };
const bool enabled = true;
var key = new DatabaseKey(keyName, keyType, columns, enabled);
var result = key.ToString();
Assert.That(result, Is.EqualTo(expectedResult));
}
public static void Ctor_GivenUniqueKeyWithNonUniqueKeyType_ThrowsArgumentException()
{
Identifier tableName = "test_table";
var columns = new[] { Mock.Of <IDatabaseColumn>() };
var primaryKey = Option <IDatabaseKey> .None;
var key = new DatabaseKey(Option <Identifier> .None, DatabaseKeyType.Foreign, columns, true);
var uniqueKeys = new[] { key };
var parentKeys = Array.Empty <IDatabaseRelationalKey>();
var childKeys = Array.Empty <IDatabaseRelationalKey>();
var indexes = Array.Empty <IDatabaseIndex>();
var checks = Array.Empty <IDatabaseCheckConstraint>();
var triggers = Array.Empty <IDatabaseTrigger>();
Assert.That(() => new RelationalDatabaseTable(tableName, columns, primaryKey, uniqueKeys, parentKeys, childKeys, indexes, checks, triggers), Throws.ArgumentException);
}
public static string FillTemplate(this DatabaseKey key, string template)
{
int indexOf = 0;
indexOf = template.IndexOf("{", indexOf, StringComparison.Ordinal);
while (indexOf != -1)
{
var keyIndex = template.Substring(indexOf + 1, template.IndexOf("}", indexOf, StringComparison.Ordinal) - indexOf - 1);
if (int.TryParse(keyIndex, out var keyIndexNum))
{
template = template.Replace("{" + keyIndex + "}", key[keyIndexNum].ToString());
}
indexOf = template.IndexOf("{", indexOf + 1, StringComparison.Ordinal);
}
return(template);
}
public IQuery GenerateDeleteQuery(DatabaseTableDefinitionJson table, DatabaseKey key)
{
var query = Queries.BeginTransaction();
if (table.ForeignTable != null)
{
foreach (var foreign in table.ForeignTable)
{
var tableKey = foreign.ForeignKeys[0];
GenerateWherePrimaryKey(foreign.ForeignKeys.Take(table.GroupByKeys.Count).ToList(), query
.Table(foreign.TableName), key).Delete();
}
}
GenerateWherePrimaryKey(table, query.Table(table.TableName), key).Delete();
return(query.Close());
}
public bool TryDeserialize(ISmartScriptProjectItem projectItem, out ISolutionItem?solutionItem)
{
solutionItem = null;
if (projectItem.Type == 32 && projectItem.StringValue != null)
{
var split = projectItem.StringValue.Split(':');
if (split.Length != 2 && split.Length != 3)
{
return(false);
}
var table = split[0];
var items = split[1].Split(',')
.Where(i => DatabaseKey.TryDeserialize(i, out var _))
.Select(DatabaseKey.Deserialize)
.Select(i => new SolutionItemDatabaseEntity(i, true));
var deletedEntries = split.Length == 2 ? null : split[2].Split(',')
.Where(i => DatabaseKey.TryDeserialize(i, out var _))
.Select(DatabaseKey.Deserialize);
var definition = tableDefinitionProvider.GetDefinition(table);
if (definition == null)
{
return(false);
}
var dbItem = new DatabaseTableSolutionItem(table, definition.IgnoreEquality);
if (string.IsNullOrEmpty(projectItem.Comment))
{
dbItem.Entries.AddRange(items);
}
else
{
var entries = JsonConvert.DeserializeObject <List <SolutionItemDatabaseEntity> >(projectItem.Comment);
dbItem.Entries.AddRange(entries);
}
if (deletedEntries != null)
{
dbItem.DeletedEntries.AddRange(deletedEntries);
}
solutionItem = dbItem;
return(true);
}
return(false);
}
public static async Task AnalyseTables_GivenTableWithPrimaryKeyWithSingleNonIntegerColumn_ProducesMessages()
{
var rule = new PrimaryKeyNotIntegerRule(RuleLevel.Error);
var dataTypeMock = new Mock <IDbType>();
dataTypeMock.Setup(t => t.DataType).Returns(DataType.Binary);
var testColumn = new DatabaseColumn(
"test_column_1",
dataTypeMock.Object,
false,
null,
null
);
var testPrimaryKey = new DatabaseKey(
Option <Identifier> .Some("test_primary_key"),
DatabaseKeyType.Primary,
new[] { testColumn },
true
);
var table = new RelationalDatabaseTable(
"test",
new List <IDatabaseColumn> {
testColumn
},
testPrimaryKey,
Array.Empty <IDatabaseKey>(),
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseRelationalKey>(),
Array.Empty <IDatabaseIndex>(),
Array.Empty <IDatabaseCheckConstraint>(),
Array.Empty <IDatabaseTrigger>()
);
var tables = new[] { table };
var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);
Assert.That(hasMessages, Is.True);
}
private static DbCommand writeCommandType <T>(object instance)
{
Map map = Maps.Map <T>();
DatabaseKey typeKey = map.PrimaryKey;
if (string.IsNullOrEmpty(map.WriteCommandText))
{
throw new NullReferenceException(string.Format("No database write defined for type : {0}", typeof(T).Name));
}
DbCommand command = null;
if (map.WriteCommandTextIsSql)
{
command = db.GetSqlStringCommand(writeCommandSql(map.WriteCommandText, typeKey.Name));
mapBoundParameters(map.WriteMap(), command, instance);
}
else
{
command = db.GetStoredProcCommand(map.WriteCommandText, objectData(map.WriteMap(), instance));
}
logCommand(command);
return(command);
}
public static bool TryLoadImage(DatabaseKey databaseKey, string name, out BitmapSource image)
{
image = null;
if (!Cache.LoadCheck(databaseKey, name, ImageExtensionName, out string filename))
{
return(false);
}
try
{
using (Diagnostics.PotentialExceptionRegion)
{
image = new BitmapImage(new Uri(Path.GetFullPath(filename), UriKind.Absolute));
}
return(true);
}
catch (Exception ex)
{
Trace.WriteLine(
$"Load image cache '{name}' for version '{databaseKey.Version}' failed: {ex.ToString()}");
return(false);
}
}
public DatabaseTableSolutionItem(DatabaseKey entry, bool existsInDatabase, string definitionId, bool ignoreEquality)
{
Entries.Add(new SolutionItemDatabaseEntity(entry, existsInDatabase));
DefinitionId = definitionId;
IgnoreEquality = ignoreEquality;
}
public DatabaseEntitiesGroupViewModel(DatabaseKey key, string name)
{
Key = key;
Name = name;
}
public DatabaseEntity CreateEmptyEntity(DatabaseTableDefinitionJson definition, DatabaseKey key, bool phantomEntity)
{
Dictionary <string, IDatabaseField> columns = new(StringComparer.InvariantCultureIgnoreCase);
foreach (var column in definition.Groups.SelectMany(t => t.Fields)
.Distinct(
EqualityComparerFactory.Create <DatabaseColumnJson>(
f => f.DbColumnName.GetHashCode(),
(a, b) => a !.DbColumnName.Equals(b !.DbColumnName))))
{
IValueHolder valueHolder;
var type = column.ValueType;
if (parameterFactory.IsRegisteredLong(type))
{
type = "uint";
}
else if (parameterFactory.IsRegisteredString(type))
{
type = "string";
}
else if (type.EndsWith("Parameter"))
{
type = "uint";
}
if (type == "float")
{
valueHolder = new ValueHolder <float>(column.Default is float f ? f : 0.0f, column.CanBeNull && column.Default == null);
}
else if (type is "int" or "uint" or "long")
{
valueHolder = new ValueHolder <long>(column.Default is long f ? f : 0, column.CanBeNull && column.Default == null);
}
public DatabaseKeyRemovedHistoryAction(MultiRowDbTableEditorViewModel viewModel,
DatabaseKey entity)
{
this.viewModel = viewModel;
this.entity = entity;
}
static DeveelDbConnectionStringBuilder()
{
defaults = new Dictionary <string, object>();
defaults.Add(HostKey, DefaultHost);
defaults.Add(PortKey, DefaultPort);
defaults.Add(DatabaseKey, DefaultDatabase);
defaults.Add(UserNameKey, DefaultUserName);
defaults.Add(PasswordKey, DefaultPassword);
defaults.Add(SchemaKey, DefaultSchema);
defaults.Add(PathKey, DefaultPath);
defaults.Add(CreateKey, DefaultCreate);
defaults.Add(BootOrCreateKey, DefaultBootOrCreate);
defaults.Add(ParameterStyleKey, DefaultParameterStyle);
defaults.Add(VerboseColumnNamesKey, DefaultVerboseColumnName);
defaults.Add(PersistSecurityInfoKey, DefaultPersistSecurityInfo);
defaults.Add(RowCacheSizeKey, DefaultRowCacheSize);
defaults.Add(MaxCacheSizeKey, DefaultMaxCacheSize);
defaults.Add(FetchSizeKey, DefaultFetchSize);
defaults.Add(MaxFetchSizeKey, DefaultMaxFetchSize);
defaults.Add(AutoCommitKey, DefaultAutoCommit);
defaults.Add(QueryTimeoutKey, DefaultQueryTimeout);
keymaps = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase);
keymaps[HostKey.ToUpper()] = HostKey;
keymaps["ADDRESS"] = HostKey;
keymaps["SERVER"] = HostKey;
keymaps[PortKey.ToUpper()] = PortKey;
keymaps[DatabaseKey.ToUpper()] = DatabaseKey;
keymaps["CATALOG"] = DatabaseKey;
keymaps["INITIAL CATALOG"] = DatabaseKey;
keymaps["DB"] = DatabaseKey;
keymaps[SchemaKey.ToUpper()] = SchemaKey;
keymaps["DEFAULT SCHEMA"] = SchemaKey;
keymaps[PathKey.ToUpper()] = PathKey;
keymaps["DATA PATH"] = PathKey;
keymaps["DATABASE PATH"] = PathKey;
keymaps["DATAPATH"] = PathKey;
keymaps["DATABASEPATH"] = PathKey;
keymaps[CreateKey.ToUpper()] = CreateKey;
keymaps[BootOrCreateKey] = BootOrCreateKey;
keymaps["BOOT OR CREATE"] = BootOrCreateKey;
keymaps["CREATE OR BOOT"] = BootOrCreateKey;
keymaps["CREATEORBOOT"] = BootOrCreateKey;
keymaps[CreateKey.ToUpper()] = CreateKey;
keymaps["CREATE DATABASE"] = CreateKey;
keymaps[UserNameKey.ToUpper()] = UserNameKey;
keymaps["USER"] = UserNameKey;
keymaps["USER NAME"] = UserNameKey;
keymaps["USER ID"] = UserNameKey;
keymaps["USERID"] = UserNameKey;
keymaps["UID"] = UserNameKey;
keymaps[PasswordKey.ToUpper()] = PasswordKey;
keymaps["PASS"] = PasswordKey;
keymaps["PWD"] = PasswordKey;
keymaps["SECRET"] = PasswordKey;
keymaps[ParameterStyleKey.ToUpper()] = ParameterStyleKey;
keymaps["PARAMSTYLE"] = ParameterStyleKey;
keymaps["PARAMETER STYLE"] = ParameterStyleKey;
keymaps["USEPARMAMETER"] = ParameterStyleKey;
keymaps["USE PARAMETER"] = ParameterStyleKey;
keymaps[VerboseColumnNamesKey.ToUpper()] = VerboseColumnNamesKey;
keymaps["VERBOSE COLUMNS"] = VerboseColumnNamesKey;
keymaps["VERBOSE COLUMN NAMES"] = VerboseColumnNamesKey;
keymaps["VERBOSECOLUMNS"] = VerboseColumnNamesKey;
keymaps["COLUMNS VERBOSE"] = VerboseColumnNamesKey;
keymaps[PersistSecurityInfoKey.ToUpper()] = PersistSecurityInfoKey;
keymaps["PERSIST SECURITY INFO"] = PersistSecurityInfoKey;
keymaps[RowCacheSizeKey.ToUpper()] = RowCacheSizeKey;
keymaps["ROW CACHE SIZE"] = RowCacheSizeKey;
keymaps["CACHE SIZE"] = RowCacheSizeKey;
keymaps[MaxCacheSizeKey.ToUpper()] = MaxCacheSizeKey;
keymaps["MAX CACHE SIZE"] = MaxCacheSizeKey;
keymaps["MAX CACHE"] = MaxCacheSizeKey;
keymaps[QueryTimeoutKey.ToUpper()] = QueryTimeoutKey;
keymaps["QUERY TIMEOUT"] = QueryTimeoutKey;
keymaps[IgnoreIdentifiersCaseKey.ToUpper()] = IgnoreIdentifiersCaseKey;
keymaps["IGNORE CASE"] = IgnoreIdentifiersCaseKey;
keymaps["IGNORE ID CASE"] = IgnoreIdentifiersCaseKey;
keymaps["ID CASE IGNORED"] = IgnoreIdentifiersCaseKey;
keymaps[StrictGetValueKey.ToUpper()] = StrictGetValueKey;
keymaps["STRICT"] = StrictGetValueKey;
keymaps["STRICT GETVALUE"] = StrictGetValueKey;
keymaps["STRICT VALUE"] = StrictGetValueKey;
keymaps["STRICTVALUE"] = StrictGetValueKey;
keymaps[FetchSizeKey.ToUpper()] = FetchSizeKey;
keymaps["FETCH SIZE"] = FetchSizeKey;
keymaps["ROW COUNT"] = FetchSizeKey;
keymaps["ROWCOUNT"] = FetchSizeKey;
keymaps[MaxFetchSizeKey.ToUpper()] = MaxFetchSizeKey;
keymaps["MAX FETCH SIZE"] = MaxFetchSizeKey;
keymaps["MAXFETCHSIZE"] = MaxFetchSizeKey;
keymaps["MAX ROW COUNT"] = MaxFetchSizeKey;
keymaps["MAX ROWCOUNT"] = MaxFetchSizeKey;
keymaps["MAXROWCOUNT"] = MaxFetchSizeKey;
keymaps[AutoCommitKey.ToUpper()] = AutoCommitKey;
keymaps["AUTOCOMMIT"] = AutoCommitKey;
keymaps["AUTO-COMMIT"] = AutoCommitKey;
keymaps["AUTO_COMMIT"] = AutoCommitKey;
keymaps["AUTO COMMIT"] = AutoCommitKey;
keymaps["COMMIT AUTO"] = AutoCommitKey;
keymaps["COMMIT_AUTO"] = AutoCommitKey;
keymaps["COMMITAUTO"] = AutoCommitKey;
keymaps["COMMIT-AUTO"] = AutoCommitKey;
keymaps["COMMIT"] = AutoCommitKey;
keymaps["ENLIST"] = EnlistKey;
}
private static IWhere GenerateWherePrimaryKey(DatabaseTableDefinitionJson definition, ITable table, DatabaseKey key)
{
return(GenerateWherePrimaryKey(definition.GroupByKeys, table, key));
}
private static IWhere GenerateWherePrimaryKey(IList <string> keys, ITable table, DatabaseKey key)
{
Debug.Assert(keys.Count == key.Count);
if (key.Count == 1)
{
return(table.Where(r => r.Column <long>(keys[0]) == key[0]));
}
else
{
var where = table.Where(r => r.Column <long>(keys[0]) == key[0]);
for (int i = 1; i < keys.Count; i++)
{
int index = i;
where = where.Where(r => r.Column <long>(keys[index]) == key[index]);
}
return(where);
}
}
