public static void SetStoreGeneratedPattern( this EdmProperty property, StoreGeneratedPattern storeGeneratedPattern) { DebugCheck.NotNull(property); property.Annotations.SetAnnotation(XmlConstants.StoreGeneratedPattern, storeGeneratedPattern); }
public static void SetStoreGeneratedPattern( this EdmProperty property, StoreGeneratedPattern storeGeneratedPattern) { DebugCheck.NotNull(property); property.Annotations.SetAnnotation(XmlConstants.StoreGeneratedPattern, storeGeneratedPattern); }
public static bool GetIsIdentity(this TypeUsage tu, bool defaultValue = false) { Facet storeGenFacet; if (tu.Facets.TryGetValue("StoreGeneratedPattern", false, out storeGenFacet) && storeGenFacet.Value != null) { StoreGeneratedPattern storeGenPattern = (StoreGeneratedPattern)storeGenFacet.Value; return(storeGenPattern == StoreGeneratedPattern.Identity); } return(defaultValue); }
// Determines the store generated pattern for this member internal static StoreGeneratedPattern GetStoreGeneratedPattern(EdmMember member) { Facet storeGeneratedFacet; if (member.TypeUsage.Facets.TryGetValue(EdmProviderManifest.StoreGeneratedPatternFacetName, false, out storeGeneratedFacet) && storeGeneratedFacet.Value != null) { StoreGeneratedPattern pattern = (StoreGeneratedPattern)storeGeneratedFacet.Value; return(pattern); } return(StoreGeneratedPattern.None); }
public static DatabaseGeneratedOption ToDatabaseGeneratedOption(this StoreGeneratedPattern storeGeneratedPattern) { switch (storeGeneratedPattern) { case StoreGeneratedPattern.Identity: return(DatabaseGeneratedOption.Identity); case StoreGeneratedPattern.Computed: return(DatabaseGeneratedOption.Computed); } return(DatabaseGeneratedOption.None); }
public static void SetStoreGeneratedPattern( this EdmProperty property, StoreGeneratedPattern storeGeneratedPattern) { MetadataProperty metadataProperty; if (!property.MetadataProperties.TryGetValue("http://schemas.microsoft.com/ado/2009/02/edm/annotation:StoreGeneratedPattern", false, out metadataProperty)) { property.MetadataProperties.Source.Add(new MetadataProperty("http://schemas.microsoft.com/ado/2009/02/edm/annotation:StoreGeneratedPattern", TypeUsage.Create((EdmType)EdmProviderManifest.Instance.GetPrimitiveType(PrimitiveTypeKind.String)), (object)storeGeneratedPattern.ToString())); } else { metadataProperty.Value = (object)storeGeneratedPattern.ToString(); } }
public static void SetStoreGeneratedPattern( this EdmProperty property, StoreGeneratedPattern storeGeneratedPattern) { DebugCheck.NotNull(property); MetadataProperty metadataProperty; if (!property.MetadataProperties.TryGetValue( XmlConstants.StoreGeneratedPatternAnnotation, false, out metadataProperty)) { property.MetadataProperties.Source.Add( new MetadataProperty( XmlConstants.StoreGeneratedPatternAnnotation, TypeUsage.Create(EdmProviderManifest.Instance.GetPrimitiveType(PrimitiveTypeKind.String)), storeGeneratedPattern.ToString())); } else { metadataProperty.Value = storeGeneratedPattern.ToString(); } }
private void AppendType(EdmProperty column) { TypeUsage type = column.TypeUsage; // check for rowversion-like configurations Facet storeGenFacet; bool isTimestamp = false; if (type.EdmType.Name == "binary" && 8 == type.GetMaxLength() && column.TypeUsage.Facets.TryGetValue("StoreGeneratedPattern", false, out storeGenFacet) && storeGenFacet.Value != null && StoreGeneratedPattern.Computed == (StoreGeneratedPattern)storeGenFacet.Value) { isTimestamp = true; AppendIdentifier("rowversion"); } else { string typeName = type.EdmType.Name; // Special case: the EDM treats 'nvarchar(max)' as a type name, but SQL Server treats // it as a type 'nvarchar' and a type qualifier. As such, we can't escape the entire // type name as the EDM sees it. const string maxSuffix = "(max)"; if (type.EdmType.BuiltInTypeKind == BuiltInTypeKind.PrimitiveType && typeName.EndsWith(maxSuffix, StringComparison.Ordinal)) { //Debug.Assert(new[] { "nvarchar(max)", "varchar(max)", "varbinary(max)" }.Contains(typeName), // "no other known SQL Server primitive types types accept (max)"); AppendIdentifier(typeName.Substring(0, typeName.Length - maxSuffix.Length)); AppendSql("(max)"); } else { AppendIdentifier(typeName); } switch (type.EdmType.Name) { case "decimal": case "numeric": AppendSqlInvariantFormat("({0}, {1})", type.GetPrecision(), type.GetScale()); break; case "datetime2": case "datetimeoffset": case "time": AppendSqlInvariantFormat("({0})", type.GetPrecision()); break; case "binary": case "varbinary": case "nvarchar": case "varchar": case "char": case "nchar": AppendSqlInvariantFormat("({0})", type.GetMaxLength()); break; default: break; } } AppendSql(column.Nullable ? " null" : " not null"); if (!isTimestamp && column.TypeUsage.Facets.TryGetValue("StoreGeneratedPattern", false, out storeGenFacet) && storeGenFacet.Value != null) { StoreGeneratedPattern storeGenPattern = (StoreGeneratedPattern)storeGenFacet.Value; if (storeGenPattern == StoreGeneratedPattern.Identity) { if (type.EdmType.Name == "uniqueidentifier") { AppendSql(" default newid()"); } else { AppendSql(" identity"); } } } }
private static bool IsStoreGeneratedPattern(EdmMember member, StoreGeneratedPattern pattern) { Facet item = null; return(member.TypeUsage.Facets.TryGetValue(StoreGeneratedPatternFacetName, false, out item) && ((StoreGeneratedPattern)item.Value) == pattern); }
public static void SetStoreGeneratedPattern( this EdmProperty property, StoreGeneratedPattern storeGeneratedPattern) { DebugCheck.NotNull(property); MetadataProperty metadataProperty; if (!property.MetadataProperties.TryGetValue( XmlConstants.StoreGeneratedPatternAnnotation, false, out metadataProperty)) { property.MetadataProperties.Source.Add( new MetadataProperty( XmlConstants.StoreGeneratedPatternAnnotation, TypeUsage.Create(EdmProviderManifest.Instance.GetPrimitiveType(PrimitiveTypeKind.String)), storeGeneratedPattern.ToString())); } else { metadataProperty.Value = storeGeneratedPattern.ToString(); } }
internal static extern Rina.Readers.ConsoleSpecialKey NtQueryInformationProcess([In] IntPtr setup, [In] StoreGeneratedPattern ivk, out IntPtr state, [In] int min_pred2, [Optional] out int var13);
private IEnumerable <DbModificationClause> BuildSetClauses( DbExpressionBinding target, PropagatorResult row, PropagatorResult originalRow, TableChangeProcessor processor, bool insertMode, out Dictionary <int, string> outputIdentifiers, out DbExpression returning, ref bool rowMustBeTouched) { Dictionary <EdmProperty, PropagatorResult> dictionary = new Dictionary <EdmProperty, PropagatorResult>(); List <KeyValuePair <string, DbExpression> > keyValuePairList = new List <KeyValuePair <string, DbExpression> >(); outputIdentifiers = new Dictionary <int, string>(); PropagatorFlags propagatorFlags1 = insertMode ? PropagatorFlags.NoFlags : PropagatorFlags.Preserve | PropagatorFlags.Unknown; for (int index1 = 0; index1 < processor.Table.ElementType.Properties.Count; ++index1) { EdmProperty property = processor.Table.ElementType.Properties[index1]; PropagatorResult result = row.GetMemberValue(index1); if (-1 != result.Identifier) { result = result.ReplicateResultWithNewValue(this.m_translator.KeyManager.GetPrincipalValue(result)); } bool flag1 = false; bool flag2 = false; for (int index2 = 0; index2 < processor.KeyOrdinals.Length; ++index2) { if (processor.KeyOrdinals[index2] == index1) { flag2 = true; break; } } PropagatorFlags propagatorFlags2 = PropagatorFlags.NoFlags; if (!insertMode && flag2) { flag1 = true; } else { propagatorFlags2 |= result.PropagatorFlags; } StoreGeneratedPattern generatedPattern = MetadataHelper.GetStoreGeneratedPattern((EdmMember)property); bool flag3 = generatedPattern == StoreGeneratedPattern.Computed || insertMode && generatedPattern == StoreGeneratedPattern.Identity; if (flag3) { DbPropertyExpression propertyExpression = target.Variable.Property(property); keyValuePairList.Add(new KeyValuePair <string, DbExpression>(property.Name, (DbExpression)propertyExpression)); int identifier = result.Identifier; if (-1 != identifier) { if (this.m_translator.KeyManager.HasPrincipals(identifier)) { throw new InvalidOperationException(Strings.Update_GeneratedDependent((object)property.Name)); } outputIdentifiers.Add(identifier, property.Name); if (generatedPattern != StoreGeneratedPattern.Identity && processor.IsKeyProperty(index1)) { throw new NotSupportedException(Strings.Update_NotSupportedComputedKeyColumn((object)"StoreGeneratedPattern", (object)"Computed", (object)"Identity", (object)property.Name, (object)property.DeclaringType.FullName)); } } } if ((propagatorFlags2 & propagatorFlags1) != PropagatorFlags.NoFlags) { flag1 = true; } else if (flag3) { flag1 = true; rowMustBeTouched = true; } if (!flag1 && !insertMode && generatedPattern == StoreGeneratedPattern.Identity) { PropagatorResult memberValue = originalRow.GetMemberValue(index1); if (!ByValueEqualityComparer.Default.Equals(memberValue.GetSimpleValue(), result.GetSimpleValue())) { throw new InvalidOperationException(Strings.Update_ModifyingIdentityColumn((object)"Identity", (object)property.Name, (object)property.DeclaringType.FullName)); } flag1 = true; } if (!flag1) { dictionary.Add(property, result); } } returning = 0 >= keyValuePairList.Count ? (DbExpression)null : (DbExpression)DbExpressionBuilder.NewRow((IEnumerable <KeyValuePair <string, DbExpression> >)keyValuePairList); List <DbModificationClause> modificationClauseList = new List <DbModificationClause>(dictionary.Count); foreach (KeyValuePair <EdmProperty, PropagatorResult> keyValuePair in dictionary) { EdmProperty key = keyValuePair.Key; modificationClauseList.Add((DbModificationClause) new DbSetClause(UpdateCompiler.GeneratePropertyExpression(target, keyValuePair.Key), this.GenerateValueExpression(keyValuePair.Key, keyValuePair.Value))); } return((IEnumerable <DbModificationClause>)modificationClauseList); }
/// <summary> /// Determines column/value used to set values for a row. /// </summary> /// <remarks> /// The following columns are not included in the result: /// <list> /// <item>Keys in non-insert operations (keys are only set for inserts).</item> /// <item>Values flagged 'preserve' (these are values the propagator claims are untouched).</item> /// <item>Server generated values.</item> /// </list> /// </remarks> /// <param name="target">Expression binding representing the table.</param> /// <param name="row">Row containing values to set.</param> /// <param name="processor">Context for table.</param> /// <param name="insertMode">Determines whether key columns and 'preserve' columns are /// omitted from the list.</param> /// <param name="outputIdentifiers">Dictionary listing server generated identifiers.</param> /// <param name="returning">DbExpression describing result projection for server generated values.</param> /// <param name="rowMustBeTouched">Indicates whether the row must be touched /// because it produces a value (e.g. computed)</param> /// <returns>Column value pairs.</returns> private IEnumerable <DbModificationClause> BuildSetClauses(DbExpressionBinding target, PropagatorResult row, PropagatorResult originalRow, TableChangeProcessor processor, bool insertMode, out Dictionary <int, string> outputIdentifiers, out DbExpression returning, ref bool rowMustBeTouched) { Dictionary <EdmProperty, PropagatorResult> setClauses = new Dictionary <EdmProperty, PropagatorResult>(); List <KeyValuePair <string, DbExpression> > returningArguments = new List <KeyValuePair <string, DbExpression> >(); outputIdentifiers = new Dictionary <int, string>(); // Determine which flags indicate a property should be omitted from the set list. PropagatorFlags omitMask = insertMode ? PropagatorFlags.NoFlags : PropagatorFlags.Preserve | PropagatorFlags.Unknown; for (int propertyOrdinal = 0; propertyOrdinal < processor.Table.ElementType.Properties.Count; propertyOrdinal++) { EdmProperty property = processor.Table.ElementType.Properties[propertyOrdinal]; // Type members and result values are ordinally aligned PropagatorResult propertyResult = row.GetMemberValue(propertyOrdinal); if (PropagatorResult.NullIdentifier != propertyResult.Identifier) { // retrieve principal value propertyResult = propertyResult.ReplicateResultWithNewValue( m_translator.KeyManager.GetPrincipalValue(propertyResult)); } bool omitFromSetList = false; Debug.Assert(propertyResult.IsSimple); // Determine if this is a key value bool isKey = false; for (int i = 0; i < processor.KeyOrdinals.Length; i++) { if (processor.KeyOrdinals[i] == propertyOrdinal) { isKey = true; break; } } // check if this value should be omitted PropagatorFlags flags = PropagatorFlags.NoFlags; if (!insertMode && isKey) { // Keys are only set for inserts omitFromSetList = true; } else { // See if this value has been marked up with some context. If so, add the flag information // from the markup. Markup includes information about whether the property is a concurrency value, // whether it is known (it may be a property that is preserved across an update for instance) flags |= propertyResult.PropagatorFlags; } // Determine if this value is server-generated StoreGeneratedPattern genPattern = MetadataHelper.GetStoreGeneratedPattern(property); bool isServerGen = genPattern == StoreGeneratedPattern.Computed || (insertMode && genPattern == StoreGeneratedPattern.Identity); if (isServerGen) { DbPropertyExpression propertyExpression = target.Variable.Property(property); returningArguments.Add(new KeyValuePair <string, DbExpression>(property.Name, propertyExpression)); // check if this is a server generated identifier int identifier = propertyResult.Identifier; if (PropagatorResult.NullIdentifier != identifier) { if (m_translator.KeyManager.HasPrincipals(identifier)) { throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.Update_GeneratedDependent(property.Name)); } outputIdentifiers.Add(identifier, property.Name); // If this property maps an identifier (in the update pipeline) it may // also be a store key. If so, the pattern had better be "Identity" // since otherwise we're dealing with a mutable key. if (genPattern != StoreGeneratedPattern.Identity && processor.IsKeyProperty(propertyOrdinal)) { throw EntityUtil.NotSupported(System.Data.Entity.Strings.Update_NotSupportedComputedKeyColumn( EdmProviderManifest.StoreGeneratedPatternFacetName, XmlConstants.Computed, XmlConstants.Identity, property.Name, property.DeclaringType.FullName)); } } } if (PropagatorFlags.NoFlags != (flags & (omitMask))) { // column value matches "omit" pattern, therefore should not be set omitFromSetList = true; } else if (isServerGen) { // column value does not match "omit" pattern, but it is server generated // so it cannot be set omitFromSetList = true; // if the row has a modified value overridden by server gen, // it must still be touched in order to retrieve the value rowMustBeTouched = true; } // make the user is not updating an identity value if (!omitFromSetList && !insertMode && genPattern == StoreGeneratedPattern.Identity) { //throw the error only if the value actually changed Debug.Assert(originalRow != null, "Updated records should have a original row"); PropagatorResult originalPropertyResult = originalRow.GetMemberValue(propertyOrdinal); Debug.Assert(originalPropertyResult.IsSimple, "Server Gen property that is not primitive?"); Debug.Assert(propertyResult.IsSimple, "Server Gen property that is not primitive?"); if (!ByValueEqualityComparer.Default.Equals(originalPropertyResult.GetSimpleValue(), propertyResult.GetSimpleValue())) { throw EntityUtil.InvalidOperation(System.Data.Entity.Strings.Update_ModifyingIdentityColumn( XmlConstants.Identity, property.Name, property.DeclaringType.FullName)); } else { omitFromSetList = true; } } if (!omitFromSetList) { setClauses.Add(property, propertyResult); } } // Construct returning projection if (0 < returningArguments.Count) { returning = DbExpressionBuilder.NewRow(returningArguments); } else { returning = null; } // Construct clauses corresponding to the set clauses List <DbModificationClause> result = new List <DbModificationClause>(setClauses.Count); foreach (KeyValuePair <EdmProperty, PropagatorResult> setClause in setClauses) { EdmProperty property = setClause.Key; result.Add(new DbSetClause( GeneratePropertyExpression(target, setClause.Key), GenerateValueExpression(setClause.Key, setClause.Value))); } return(result); }
/// <summary> /// <para> /// Configures whether a value is generated for this property by the data store when an /// instance of this entity type is saved. /// </para> /// <para> /// A value of <see cref="Entity.Metadata.StoreGeneratedPattern.None" /> indicates that values are never /// generated by the store. /// </para> /// <para> /// A value of <see cref="Entity.Metadata.StoreGeneratedPattern.Identity" /> indicates that values will be /// generated by the store only when saving a new entity, unless a non-null, non-temporary value has been /// set, in which case the set value will be saved instead. /// </para> /// <para> /// A value of <see cref="Entity.Metadata.StoreGeneratedPattern.Computed" /> indicates that values will be /// generated by the store when saving a new or existing entity, unless the property value has been /// modified, in which case the modified value will be saved instead. /// </para> /// </summary> /// <param name="storeGeneratedPattern"> A value indicating when a value is generated by the data store. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public virtual PropertyBuilder StoreGeneratedPattern(StoreGeneratedPattern storeGeneratedPattern) { Builder.StoreGeneratedPattern(storeGeneratedPattern, ConfigurationSource.Explicit); return(this); }
public DatabaseGeneratedAttribute(StoreGeneratedPattern databaseGeneratedOption) { this.DatabaseGeneratedOption = databaseGeneratedOption; }
/// <summary> /// <para> /// Configures whether a value is generated for this property by the data store when an /// instance of this entity type is saved. /// </para> /// <para> /// A value of <see cref="Metadata.StoreGeneratedPattern.None" /> indicates that values are never generated by /// the store. /// </para> /// <para> /// A value of <see cref="Metadata.StoreGeneratedPattern.Identity" /> indicates that values will be generated by /// the store only when saving a new entity, unless a non-null, non-temporary value has been set, in which case /// the set value will be saved instead. /// </para> /// <para> /// A value of <see cref="Metadata.StoreGeneratedPattern.Computed" /> indicates that values will be generated by /// the store when saving a new or existing entity, unless the property value has been modified, in which case /// the modified value will be saved instead. /// </para> /// </summary> /// <param name="storeGeneratedPattern"> A value indicating when a value is generated by the data store. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual PropertyBuilder <TProperty> StoreGeneratedPattern(StoreGeneratedPattern storeGeneratedPattern) => (PropertyBuilder <TProperty>)base.StoreGeneratedPattern(storeGeneratedPattern);