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); } }