コード例 #1
0
            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);
            }
コード例 #2
0
        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);
                }
            }
        }
コード例 #3
0
ファイル: Hardware.cs プロジェクト: akaer/IdentityManager.SDL
        /// <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);
        }
コード例 #4
0
        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")));
        }
コード例 #5
0
ファイル: Hardware.cs プロジェクト: akaer/IdentityManager.SDL
        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);
        }
コード例 #6
0
        /// <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
            {
            }
        }
コード例 #7
0
            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);
 }
コード例 #9
0
 public void AddEntity(DbObjectKey key, EntityType type)
 {
     _entityLookup.Add(key, type);
     _reverseEntityLookup.Add(type, key);
 }
コード例 #10
0
 public bool ContainsTableWithoutKey(DbObjectKey tableKey)
 {
     return(_tablesWithoutKeys.Contains(tableKey));
 }
コード例 #11
0
 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 TryGetTvfReturnType(DbObjectKey key, out RowType type)
 {
     return _tvfReturnTypeLookup.TryGetValue(key, out type);
 }
 public void AddTvfReturnType(DbObjectKey key, RowType type)
 {
     _tvfReturnTypeLookup.Add(key, type);
 }
コード例 #15
0
        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);
            }
        }
コード例 #16
0
        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);
                }
            }
        }
コード例 #17
0
        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;
        }
コード例 #18
0
        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;
        }
コード例 #19
0
        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;
            }
コード例 #21
0
 public void AddTvfReturnType(DbObjectKey key, RowType type)
 {
     _tvfReturnTypeLookup.Add(key, type);
 }
コード例 #22
0
 public bool TryGetTvfReturnType(DbObjectKey key, out RowType type)
 {
     return(_tvfReturnTypeLookup.TryGetValue(key, out type));
 }
コード例 #23
0
        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);
 }