public override bool Equals(object obj) { if (!(obj is DbObjectKey)) { return(false); } DbObjectKey key = (DbObjectKey)obj; if (key._catalog != _catalog) { return(false); } if (key._schema != _schema) { return(false); } if (key._name != _name) { return(false); } // objectType does not count in equality return(true); }
private async Task _HandleIsProfileApplication(LogicParameter lp) { ISqlFormatter fSQL = lp.SqlFormatter; // Objekt wurde gelöscht if (lp.Entity.IsDeleted()) { // geloescht // gibt es noch andere Profile ??? string strWhereClause = fSQL.AndRelation(fSQL.UidComparison("UID_Application", lp.Entity.GetValue <string>("UID_Application")), fSQL.UidComparison("UID_Profile", lp.Entity.GetValue <string>("UID_Profile"), CompareOperator.NotEqual) ); // nein if (!await lp.Session.Source().ExistsAsync("ApplicationProfile", strWhereClause, lp.CancellationToken).ConfigureAwait(false)) { DbObjectKey dbokApplication = DbObjectKey.GetObjectKey("Application", lp.Entity.GetValue <string>("UID_Application")); TryResult <IEntity> trApplication = await lp.Session.Source().TryGetAsync(dbokApplication, lp.CancellationToken).ConfigureAwait(false); if (trApplication.Success && trApplication.Result.GetValue <bool>("IsProfileApplication")) { trApplication.Result.SetValue("IsProfileApplication", false); await lp.UnitOfWork.PutAsync(trApplication.Result, lp.CancellationToken).ConfigureAwait(false); } } } // Objekt wurde neu angelegt if (!lp.Entity.IsLoaded) { DbObjectKey dbokApplication = DbObjectKey.GetObjectKey("Application", lp.Entity.GetValue <string>("UID_Application")); TryResult <IEntity> trApplication = await lp.Session.Source().TryGetAsync(dbokApplication, lp.CancellationToken).ConfigureAwait(false); if (trApplication.Success && ! trApplication.Result.GetValue <bool>("IsProfileApplication")) { // mark as IsProfileApplication trApplication.Result.SetValue("IsProfileApplication", true); await lp.UnitOfWork.PutAsync(trApplication.Result, lp.CancellationToken).ConfigureAwait(false); } } }
/// <exclude/> /// <summary> /// Test, ob HW und MachineType der HW in der gleichen Domäne sind /// </summary> private async Task <bool> Check_SDLDomainRD(ISession session, IEntity entity, IEntityWalker walker, string uidSDLDomainRD, CancellationToken ct) { if (!session.MetaData().IsTableEnabled("MachineType")) { return(true); } // wenn Spalte leer ist -> raus if (String.IsNullOrEmpty(uidSDLDomainRD)) { return(true); } DbObjectKey dbokMachineType = DbObjectKey.GetObjectKey("MachineType", entity.GetValue <string>("UID_MachineType")); var trMachineType = await session.Source().TryGetAsync(dbokMachineType, ct).ConfigureAwait(false); // FK not valid if (!trMachineType.Success) { return(true); } // compare the domain-id's if (!String.Equals(uidSDLDomainRD, trMachineType.Result.GetValue <string>("UID_SDLDomain"), StringComparison.OrdinalIgnoreCase)) { // try to find same mactype name in new resource domain ISqlFormatter fSQL = session.Resolve <ISqlFormatter>(); string strWhereClause = fSQL.AndRelation( fSQL.Comparison("Ident_MachineType", trMachineType.Result.GetValue <string>("Ident_MachineType"), ValType.String, CompareOperator.Equal), fSQL.UidComparison("UID_SDLDomain", uidSDLDomainRD)); // query for this object var uidMachineType = await session.Source().TryGetSingleValueAsync <string>("MachineType", "UID_MachineType", strWhereClause, ct).ConfigureAwait(false); await entity.PutValueAsync("UID_MachineType", uidMachineType.Success?uidMachineType.Result : "", ct).ConfigureAwait(false); } return(true); }
private static async Task <bool> _RootAppsIsTAS(ISession session, IEntity entity, string uidServerTas, bool with2116144, CancellationToken ct) { IEntity dbTasServer; if (!String.IsNullOrEmpty(uidServerTas)) { DbObjectKey dbokServerTas = DbObjectKey.GetObjectKey("QBMServer", uidServerTas); var trServerTas = await session.Source().TryGetAsync(dbokServerTas, ct).ConfigureAwait(false); if (!trServerTas.Success) { throw new ViException(2116052, ExceptionRelevance.EndUser, uidServerTas); } dbTasServer = trServerTas.Result; } else { IEntityForeignKey fkServerTas = await entity.GetFkAsync(session, "UID_ServerTas", ct).ConfigureAwait(false); if (!fkServerTas.IsEmpty()) { dbTasServer = await fkServerTas.GetParentAsync(EntityLoadType.Default, ct).ConfigureAwait(false); } else { if (with2116144) { throw new ViException(2116144, ExceptionRelevance.EndUser); } return(false); } } IEntity dbRootAppServer = await _GetRootAppServer(session, entity, false, ct).ConfigureAwait(false); return(String.Equals(dbRootAppServer.GetValue <string>("Ident_Server"), dbTasServer.GetValue <string>("Ident_Server"))); }
private async Task <bool> Check_MachineType(ISession session, IEntity entity, IEntityWalker walker, string uidMachineType, CancellationToken ct) { if (!session.MetaData().IsTableEnabled("MachineType")) { return(true); } // wenn Spalte nicht geladen wurde if (String.IsNullOrEmpty(uidMachineType)) { return(true); } // no SDL domain defined string sdlDomain = entity.GetValue <string>("UID_SDLDomainRD"); if (String.IsNullOrEmpty(sdlDomain)) { return(true); } DbObjectKey dbokMachineType = DbObjectKey.GetObjectKey("MachineType", uidMachineType); var trMachineType = await session.Source().TryGetAsync(dbokMachineType, ct).ConfigureAwait(false); // FK not valid if (!trMachineType.Success) { return(true); } // compare the domain-id's if (!String.Equals(sdlDomain, trMachineType.Result.GetValue <string>("UID_SDLDomain"), StringComparison.OrdinalIgnoreCase)) { throw new ViException(2133091, ExceptionRelevance.EndUser); } return(true); }
/// <summary> /// Wird aufgerufen, bevor der MainActivator aktiviert wird. /// Hier sollten alle von einem DB-Objekt abhängige Initialisierungen /// durchgeführt werden. /// </summary> private void MainActivator_OnActivating(object sender, System.EventArgs e) { try { // Aktivierung mit <null> verhindern if (m_MainActivator.DbObject == null) { return; } m_ShrinkFrame3.VisibleByUser = Connection.GetConfigParm(@"Software\SoftwareDistribution\Replication\ReplJobDelay") == "1"; // mit einem Clone aktivieren, damit der Save-Button im Manager nie enabled wird if (m_Clone == null) { m_Clone = new DbObjectKey(m_MainActivator.DbObject).GetObject(Connection); m_MainActivator.DbObject = m_Clone; } } finally { } }
public bool TryGetEntity(DbObjectKey key, out EntityType type) { if (_entityLookup.TryGetValue(key, out type)) { return(true); } //Ignore relationships which refer to table without keys if (ContainsTableWithoutKey(key)) { return(false); } if (!_missingEntities.Contains(key)) { AddErrorsForType(null, new EdmSchemaError( Strings.TableReferencedByAssociationWasNotFound(key), (int)ModelBuilderErrorCode.MissingEntity, EdmSchemaErrorSeverity.Error)); _missingEntities.Add(key); } return(false); }
public void AddTableWithoutKey(DbObjectKey tableKey) { _tablesWithoutKeys.Add(tableKey); }
public void AddEntity(DbObjectKey key, EntityType type) { _entityLookup.Add(key, type); _reverseEntityLookup.Add(type, key); }
public bool ContainsTableWithoutKey(DbObjectKey tableKey) { return(_tablesWithoutKeys.Contains(tableKey)); }
public bool TryGetTvfReturnType(DbObjectKey key, out RowType type) { return _tvfReturnTypeLookup.TryGetValue(key, out type); }
public void AddTvfReturnType(DbObjectKey key, RowType type) { _tvfReturnTypeLookup.Add(key, type); }
private void CreateEdmFunction(LoadMethodSessionState session, DbObjectKey functionKey, List<FunctionDetailsReader.Memento> parameters) { Debug.Assert(parameters.Count != 0, "don't call the method with no data"); FunctionDetailsReader row = parameters[0].CreateReader(); FunctionParameter returnParameter = null; bool isValid = true; List<EdmSchemaError> errors = new List<EdmSchemaError>(); if (row.ReturnType != null) { Debug.Assert(!row.IsTvf, "TVF can't have ReturnType (used only for scalars)."); bool excludedForTarget; TypeUsage returnType = GetScalarFunctionTypeUsage(session, row.ReturnType, out excludedForTarget); if (returnType != null) { returnParameter = new FunctionParameter(EdmConstants.ReturnType, returnType, ParameterMode.ReturnValue); } else { isValid = false; errors.Add(new EdmSchemaError(excludedForTarget ? Strings.UnsupportedFunctionReturnDataTypeForTarget(row.ProcedureName, row.ReturnType) : Strings.UnsupportedFunctionReturnDataType(row.ProcedureName, row.ReturnType), (int)ModelBuilderErrorCode.UnsupportedType, EdmSchemaErrorSeverity.Warning)); } } else if (row.IsTvf) { if (_targetEntityFrameworkVersion < EntityFrameworkVersions.Version3) { return; } RowType tvfReturnType; if (session.TryGetTvfReturnType(functionKey, out tvfReturnType) && !session.InvalidTypes.Contains(tvfReturnType)) { var collectionType = tvfReturnType.GetCollectionType(); collectionType.SetReadOnly(); returnParameter = new FunctionParameter(EdmConstants.ReturnType, TypeUsage.Create(collectionType), ParameterMode.ReturnValue); } else { isValid = false; // If the TVF return type exists, but it is not valid, then reassign all its errors directly to the TVF. // This is needed in order to avoid the following kind of error reporting: // SSDL: // // <!-- Errors found while generating type: // column1 type not supported // column2 type not supported // <RowType /> // --> // ... // ... // <!-- Error found while generating type: // TableReferencedByTvfWasNotFound // <Function Name="TVF" .... /> // --> // // Instead we want something like this: // // <!-- Errors found while generating type: // column1 type not supported // column2 type not supported // TableReferencedByTvfWasNotFound // <Function Name="TVF" .... /> // --> // List<EdmSchemaError> tvfReturnTypeErrors; if (tvfReturnType != null && session.ItemToErrorsMap.TryGetValue(tvfReturnType, out tvfReturnTypeErrors)) { errors.AddRange(tvfReturnTypeErrors); session.ItemToErrorsMap.Remove(tvfReturnType); if (session.InvalidTypes.Contains(tvfReturnType)) { session.InvalidTypes.Remove(tvfReturnType); } } errors.Add(new EdmSchemaError( Strings.TableReferencedByTvfWasNotFound(functionKey), (int)ModelBuilderErrorCode.MissingTvfReturnTable, EdmSchemaErrorSeverity.Warning)); } } bool caseSensitive = false; UniqueIdentifierService uniqueIdentifiers = new UniqueIdentifierService(caseSensitive); List<FunctionParameter> functionParameters = new List<FunctionParameter>(); for (int i = 0; i < parameters.Count && !row.IsParameterNameNull; i++) { row.Attach(parameters[i]); TypeUsage parameterType = null; bool excludedForTarget = false; if (!row.IsParameterTypeNull) { parameterType = GetScalarFunctionTypeUsage(session, row.ParameterType, out excludedForTarget); } if (parameterType != null) { ParameterMode mode; if (!row.TryGetParameterMode(out mode)) { isValid = false; string modeValue = "null"; if (!row.IsParameterModeNull) { modeValue = row.ProcParameterMode; } errors.Add(new EdmSchemaError( Strings.ParameterDirectionNotValid( row.ProcedureName, row.ParameterName, modeValue), (int)ModelBuilderErrorCode.ParameterDirectionNotValid, EdmSchemaErrorSeverity.Warning)); } // the mode will get defaulted to something, so it is ok to keep creating after // an error getting the mode value. string parameterName = EntityModelSchemaGenerator.CreateValidEcmaName(row.ParameterName, 'p'); parameterName = uniqueIdentifiers.AdjustIdentifier(parameterName); FunctionParameter parameter = new FunctionParameter(parameterName, parameterType, mode); functionParameters.Add(parameter); } else { isValid = false; string typeValue = "null"; if (!row.IsParameterTypeNull) { typeValue = row.ParameterType; } errors.Add(new EdmSchemaError(excludedForTarget ? Strings.UnsupportedFunctionParameterDataTypeForTarget(row.ProcedureName, row.ParameterName, i, typeValue) : Strings.UnsupportedFunctionParameterDataType(row.ProcedureName, row.ParameterName, i, typeValue), (int)ModelBuilderErrorCode.UnsupportedType, EdmSchemaErrorSeverity.Warning)); } } string functionName = EntityModelSchemaGenerator.CreateValidEcmaName(row.ProcedureName, 'f'); functionName = session.UsedTypeNames.AdjustIdentifier(functionName); FunctionParameter[] returnParameters = returnParameter == null ? new FunctionParameter[0] : new FunctionParameter[] {returnParameter}; EdmFunction function = new EdmFunction(functionName, _namespaceName, DataSpace.SSpace, new EdmFunctionPayload { Schema = row.Schema, StoreFunctionName = functionName != row.ProcedureName ? row.ProcedureName : null, IsAggregate = row.IsIsAggregate, IsBuiltIn = row.IsBuiltIn, IsNiladic = row.IsNiladic, IsComposable = row.IsComposable, ReturnParameters = returnParameters, Parameters = functionParameters.ToArray() }); function.SetReadOnly(); session.AddErrorsForType(function, errors); if (isValid) { session.Functions.Add(function); } else { session.InvalidTypes.Add(function); } }
private void CreateEdmFunctions(LoadMethodSessionState session) { using(FunctionDetailsReader reader = _loader.LoadFunctionDetails(session.Filters)) { DbObjectKey currentFunction = new DbObjectKey(); List<FunctionDetailsReader.Memento> parameters = new List<FunctionDetailsReader.Memento>(); while(reader.Read()) { DbObjectKey rowFunction = reader.CreateDbObjectKey(); if (rowFunction != currentFunction) { if (!currentFunction.IsEmpty) { CreateEdmFunction(session, currentFunction, parameters); parameters.Clear(); } currentFunction = rowFunction; } parameters.Add(reader.CreateMemento()); } if (parameters.Count != 0) { CreateEdmFunction(session, currentFunction, parameters); } } }
private bool InferKeyColumns(LoadMethodSessionState session, IList<TableDetailsRow> columns, List<string> pKeys, DbObjectKey tableKey, ref ICollection<string> primaryKeys) { for (int i = 0; i < columns.Count; i++) { if (!columns[i].IsNullable) { PrimitiveType primitiveType; bool _; if (session.TryGetStorePrimitiveType(columns[i].DataType, out primitiveType, out _) && MetadataUtil.IsValidKeyType(_targetEntityFrameworkVersion, primitiveType)) { pKeys.Add(columns[i].ColumnName); } } } // if there are valid key column candidates, make them the new key columns if (pKeys.Count > 0) { primaryKeys = pKeys; } else { primaryKeys = null; } return primaryKeys != null; }
private IList<EdmProperty> CreateEdmProperties( LoadMethodSessionState session, IList<TableDetailsRow> columns, DbObjectKey tableKey, List<EdmSchemaError> errors, out IList<string> excludedColumns) { Debug.Assert(columns.Count != 0, "columns.Count != 0"); Debug.Assert(errors != null, "errors != null"); var members = new List<EdmProperty>(); excludedColumns = new List<string>(); foreach (TableDetailsRow row in columns) { PrimitiveType primitiveType; bool excludedForTarget = false; if (row.IsDataTypeNull() || !session.TryGetStorePrimitiveType(row.DataType, out primitiveType, out excludedForTarget)) { string message; if (!row.IsDataTypeNull()) { message = excludedForTarget ? Strings.UnsupportedDataTypeForTarget(row.DataType, row.GetMostQualifiedTableName(), row.ColumnName) : Strings.UnsupportedDataType(row.DataType, row.GetMostQualifiedTableName(), row.ColumnName); } else { message = Strings.UnsupportedDataTypeUnknownType(row.ColumnName, row.GetMostQualifiedTableName()); } errors.Add(new EdmSchemaError(message, (int)ModelBuilderErrorCode.UnsupportedType, EdmSchemaErrorSeverity.Warning)); excludedColumns.Add(row.ColumnName); continue; } Dictionary<string, Facet> facets = primitiveType.GetAssociatedFacetDescriptions().ToDictionary(fd => fd.FacetName, fd => fd.DefaultValueFacet); facets[DbProviderManifest.NullableFacetName] = Facet.Create(facets[DbProviderManifest.NullableFacetName].Description, row.IsNullable); if (primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Decimal) { Facet precision; if (facets.TryGetValue(DbProviderManifest.PrecisionFacetName, out precision)) { if (!row.IsPrecisionNull() && !precision.Description.IsConstant) { if (row.Precision < precision.Description.MinValue || row.Precision > precision.Description.MaxValue) { DbObjectKey key = row.CreateDbObjectKey(tableKey.ObjectType); errors.Add(new EdmSchemaError( Strings.ColumnFacetValueOutOfRange( DbProviderManifest.PrecisionFacetName, row.Precision, precision.Description.MinValue, precision.Description.MaxValue, row.ColumnName, key), (int)ModelBuilderErrorCode.FacetValueOutOfRange, EdmSchemaErrorSeverity.Warning)); excludedColumns.Add(row.ColumnName); continue; } facets[precision.Name] = Facet.Create(precision.Description, (byte)row.Precision); } } Facet scale; if (facets.TryGetValue(DbProviderManifest.ScaleFacetName, out scale)) { if (!row.IsScaleNull() && !scale.Description.IsConstant) { if (row.Scale < scale.Description.MinValue || row.Scale > scale.Description.MaxValue) { DbObjectKey key = row.CreateDbObjectKey(tableKey.ObjectType); errors.Add(new EdmSchemaError( Strings.ColumnFacetValueOutOfRange( DbProviderManifest.ScaleFacetName, row.Scale, scale.Description.MinValue, scale.Description.MaxValue, row.ColumnName, key), (int)ModelBuilderErrorCode.FacetValueOutOfRange, EdmSchemaErrorSeverity.Warning)); excludedColumns.Add(row.ColumnName); continue; } facets[scale.Name] = Facet.Create(scale.Description, (byte)row.Scale); } } } else if (primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.DateTime || primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Time || primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.DateTimeOffset) { Facet datetimePrecision; if (facets.TryGetValue(DbProviderManifest.PrecisionFacetName, out datetimePrecision)) { if (!row.IsDateTimePrecisionNull() && !datetimePrecision.Description.IsConstant) { if (row.DateTimePrecision < datetimePrecision.Description.MinValue || row.DateTimePrecision > datetimePrecision.Description.MaxValue) { DbObjectKey key = row.CreateDbObjectKey(tableKey.ObjectType); errors.Add(new EdmSchemaError( Strings.ColumnFacetValueOutOfRange( DbProviderManifest.PrecisionFacetName, row.DateTimePrecision, datetimePrecision.Description.MinValue, datetimePrecision.Description.MaxValue, row.ColumnName, key), (int)ModelBuilderErrorCode.FacetValueOutOfRange, EdmSchemaErrorSeverity.Warning)); excludedColumns.Add(row.ColumnName); continue; } facets[datetimePrecision.Name] = Facet.Create(datetimePrecision.Description, (byte)row.DateTimePrecision); } } } else if (primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.String || primitiveType.PrimitiveTypeKind == PrimitiveTypeKind.Binary) { Facet maxLength; if (facets.TryGetValue(DbProviderManifest.MaxLengthFacetName, out maxLength)) { if (!row.IsMaximumLengthNull() && !maxLength.Description.IsConstant) { if (row.MaximumLength < maxLength.Description.MinValue || row.MaximumLength > maxLength.Description.MaxValue) { DbObjectKey key = row.CreateDbObjectKey(tableKey.ObjectType); errors.Add(new EdmSchemaError( Strings.ColumnFacetValueOutOfRange( DbProviderManifest.MaxLengthFacetName, row.MaximumLength, maxLength.Description.MinValue, maxLength.Description.MaxValue, row.ColumnName, key), (int)ModelBuilderErrorCode.FacetValueOutOfRange, EdmSchemaErrorSeverity.Warning)); excludedColumns.Add(row.ColumnName); continue; } facets[maxLength.Name] = Facet.Create(maxLength.Description, row.MaximumLength); } } } if (!row.IsIsIdentityNull() && row.IsIdentity) { Facet facet = Facet.Create(System.Data.Metadata.Edm.Converter.StoreGeneratedPatternFacet, StoreGeneratedPattern.Identity); facets.Add(facet.Name, facet); } else if (!row.IsIsServerGeneratedNull() && row.IsServerGenerated) { Facet facet = Facet.Create(System.Data.Metadata.Edm.Converter.StoreGeneratedPatternFacet, StoreGeneratedPattern.Computed); facets.Add(facet.Name, facet); } members.Add(new EdmProperty(row.ColumnName, TypeUsage.Create(primitiveType, facets.Values))); } return members; }
private void CreateTableTypes( LoadMethodSessionState session, IEnumerable<DataRow> tableDetailsRows, Action< LoadMethodSessionState/*session*/, IList<TableDetailsRow>/*columns*/, ICollection<string>/*primaryKeys*/, DbObjectType/*objectType*/, List<EdmSchemaError>/*errors*/> createType, DbObjectType objectType) { DbObjectKey currentKey = new DbObjectKey(); List<TableDetailsRow> singleTableColumns = new List<TableDetailsRow>(); List<string> primaryKeys = new List<string>(); foreach (TableDetailsRow row in tableDetailsRows) { DbObjectKey rowKey = row.CreateDbObjectKey(objectType); if (rowKey != currentKey) { if (singleTableColumns.Count != 0) { createType( session, singleTableColumns, primaryKeys, objectType, null); singleTableColumns.Clear(); primaryKeys.Clear(); } currentKey = rowKey; } singleTableColumns.Add(row); if (row.IsPrimaryKey) { primaryKeys.Add(row.ColumnName); } } // pick up the last one if (singleTableColumns.Count != 0) { createType( session, singleTableColumns, primaryKeys, objectType, null); } }
public bool TryGetEntity(DbObjectKey key, out EntityType type) { if (_entityLookup.TryGetValue(key, out type)) { return true; } //Ignore relationships which refer to table without keys if (ContainsTableWithoutKey(key)) { return false; } if (!_missingEntities.Contains(key)) { AddErrorsForType(null, new EdmSchemaError( Strings.TableReferencedByAssociationWasNotFound(key), (int)ModelBuilderErrorCode.MissingEntity, EdmSchemaErrorSeverity.Error)); _missingEntities.Add(key); } return false; }
public bool TryGetTvfReturnType(DbObjectKey key, out RowType type) { return(_tvfReturnTypeLookup.TryGetValue(key, out type)); }
private bool TryGetEndEntities( LoadMethodSessionState session, RelationshipDetailsRow row, out EntityType pkEntityType, out EntityType fkEntityType) { RelationshipDetailsCollection table = row.Table; DbObjectKey pkKey = new DbObjectKey(row[table.PKCatalogColumn], row[table.PKSchemaColumn], row[table.PKTableColumn], DbObjectType.Unknown); DbObjectKey fkKey = new DbObjectKey(row[table.FKCatalogColumn], row[table.FKSchemaColumn], row[table.FKTableColumn], DbObjectType.Unknown); bool worked = session.TryGetEntity(pkKey, out pkEntityType); worked &= session.TryGetEntity(fkKey, out fkEntityType); return worked; }
public bool ContainsTableWithoutKey(DbObjectKey tableKey) { return _tablesWithoutKeys.Contains(tableKey); }