private void AddSequence(string table, string seqName, IPropertyMap identiProperty) { if (identiProperty == null) { return; } if (identiProperty.KeyType == KeyType.Identity || identiProperty.KeyType == KeyType.TriggerIdentity) { string sequence = seqName; if (string.IsNullOrEmpty(seqName)) { sequence = "S_" + table; } SequenceDefinition seq = new SequenceDefinition(); seq.MaxValue = 10000000000;// seq.MinValue = 0; seq.StartWith = 1; seq.Increment = 1; seq.Name = sequence; seq.Cache = 2; _provider.AddSequence(seq); TriggerDefinition trg = new TriggerDefinition(); trg.Name = "TRG_" + table; //trg.TriggerBody = string.Format(" SELECT {0}.nextval INTO :new.id FROM dual; ", seq.Name); trg.TriggerBody = string.Format(" SELECT {0}.nextval INTO :new.{1} FROM dual; ", seq.Name, identiProperty.ColumnName); trg.Table = table; trg.OnAfter = false; trg.Type = TriggerType.Insert; _provider.AddTrigger(trg); } }
public DbSequenceInfo GetSequence(SequenceDefinition sequence) { var dbSeq = Sequences.FirstOrDefault(s => s.Definition == sequence); Util.Check(dbSeq != null, "DB Sequence {0} not found. ", sequence?.Name); return(dbSeq); }
/// <summary> /// Generates types for sequence fields /// </summary> /// <param name="emitter">The emitter to write to</param> /// <param name="def">The sequence definition</param> private void _generateSequenceFields(CSharpEmitter emitter, SequenceDefinition def) { foreach (var field in def.Fields) { var effectiveFieldName = _sequenceFieldEffectiveNameForType(field); _generateDefinition(emitter, null, effectiveFieldName, field.Type); } }
public DbSequenceInfo(DbModel model, SequenceDefinition definition) : base(model, GetSchema(model, definition), DbObjectType.Sequence, definition) { Name = definition.Name; DbType = model.Driver.TypeRegistry.GetDbTypeInfo(definition.DataType, 0); StartValue = definition.StartValue; Increment = definition.Increment; Definition = definition; FullName = model.Driver.FormatFullName(Schema, Name); }
public void WhenDefaultSchemaConventionIsAppliedAndSchemaIsSetThenSchemaShouldNotBeChanged() { var sequenceDefinition = new SequenceDefinition { Name = "Test", SchemaName = "testschema" }; sequenceDefinition.ApplyConventions(new MigrationConventions()); Assert.That(sequenceDefinition.SchemaName, Is.EqualTo("testschema")); }
public override void AddSequence(SequenceDefinition seq) { if (string.IsNullOrEmpty(seq.Name)) { return; } if (SequenceExists(seq.Name)) { return; } var result = new StringBuilder(string.Format("CREATE SEQUENCE ")); if (string.IsNullOrEmpty(_schemaName)) { result.AppendFormat((seq.Name)); } else { result.AppendFormat("{0}.{1}", _schemaName, (seq.Name)); } if (seq.Increment.HasValue) { result.AppendFormat(" INCREMENT BY {0}", seq.Increment); } if (seq.MinValue.HasValue) { result.AppendFormat(" MINVALUE {0}", seq.MinValue); } if (seq.MaxValue.HasValue) { result.AppendFormat(" MAXVALUE {0}", seq.MaxValue); } if (seq.StartWith.HasValue) { result.AppendFormat(" START WITH {0}", seq.StartWith); } if (seq.Cache.HasValue) { result.AppendFormat(" CACHE {0}", seq.Cache); } if (seq.Cycle) { result.Append(" CYCLE"); } ExecuteNonQuery(result.ToString()); }
public DbSequenceInfo(DbModel model, SequenceDefinition definition) : base(model, definition.Module.Area.Name, DbObjectType.Sequence, definition) { Name = definition.Name; var stype = model.Driver.TypeRegistry.GetDbTypeDef(definition.DataType); DbTypeName = stype.Name; StartValue = definition.StartValue; Increment = definition.Increment; Definition = definition; FullName = model.FormatFullName(Schema, Name); }
public object GetSequenceNextValue(EntitySession session, SequenceDefinition sequence) { var dbSeq = this.DbModel.LookupDbObject<DbSequenceInfo>(sequence, throwNotFound: true); var conn = GetConnection(session); try { var dbCmd = this.CreateDbCommand(dbSeq.GetNextValueCommand, conn); var result = ExecuteDbCommand(dbCmd, conn, DbExecutionType.Scalar); ReleaseConnection(conn); return result; } catch { ReleaseConnection(conn, inError: true); throw; } }
}//method public object GetSequenceNextValue(EntitySession session, SequenceDefinition sequence) { var dbSeq = this.DbModel.LookupDbObject <DbSequenceInfo>(sequence, throwNotFound: true); var conn = GetConnection(session); try { var dbCmd = this.CreateDbCommand(dbSeq.GetNextValueCommand, conn); var result = ExecuteDbCommand(dbCmd, conn, DbExecutionType.Scalar); ReleaseConnection(conn); return(result); } catch { ReleaseConnection(conn, inError: true); throw; } }
public Sequence(SequenceDefinition definition, ByteStream queue) { this.Definition = definition; Values = new Hashtable(); IList specs = definition.Elements; for (int i = 0; i < specs.Count; i++) { SequenceDefinition.ElementSpecification spec = (SequenceDefinition.ElementSpecification)specs[i]; if (spec.IsSequenceOf) { if (spec.IsOptional) { Values[spec.Id] = readOptionalSequenceOf(queue, spec.Type, spec.ContextId); } else { if (spec.HasContextId) { Values[spec.Id] = readSequenceOf(queue, spec.Type, spec.ContextId); } else { Values[spec.Id] = readSequenceOf(queue, spec.Type); } } } else if (spec.IsOptional) { Values[spec.Id] = readOptional(queue, spec.Type, spec.ContextId); } else if (spec.HasContextId) { Values[spec.Id] = read(queue, spec.Type, spec.ContextId); } else { Values[spec.Id] = read(queue, spec.Type); } } }
public void Truncate(SequenceDefinition sequence) { sequence.Name = Truncate(sequence.Name); }
public Sequence(SequenceDefinition definition, Hashtable values) { this.Definition = definition; this.Values = values; }
public Sequence(SequenceDefinition definition, ByteStream queue, int contextId) : this(definition, popStart0(queue, contextId)) { Encodable.popEnd(queue, contextId); }
private static string GetSchema(DbModel model, SequenceDefinition sequence) { return sequence.ExplicitSchema ?? model.Config.GetSchema(sequence.Module.Area); }
/// <summary> /// Generates a sequence type /// </summary> /// <param name="typeName">The name of the type</param> /// <param name="def">The sequence definition</param> private void _generateSequence(CSharpEmitter emitter, string typeName, string fieldName, SequenceDefinition def, bool root = false, string tag = null, string choiceBase = null) { string[] bases = choiceBase == null ? new string[0] { } : new string[] { choiceBase }; typeName = _getDefinitionName(typeName, fieldName, def); using (var cls = emitter.Class(typeName, false, bases)) { if (tag != null) { cls.OverrideProperty("Tag", "Tags", "return Tags." + tag + ";"); cls.WriteLine(); } foreach (var field in def.Fields) { var fieldName2 = _transformFieldName(field.Name); var typeName2 = _sequenceFieldTypeName(field); cls.Property(fieldName2, typeName2); cls.WriteLine(); } var cparams = def.Fields.Select(f => new Parameter( _sequenceFieldTypeName(f), _fieldNameToTempName(f.Name))) .ToArray(); using (var cons = cls.Constructor(typeName, cparams, Access.Public)) { foreach (var field in def.Fields) { cons.WriteLine("this.{0} = {1};", _transformFieldName(field.Name), _fieldNameToTempName(field.Name)); } } cls.WriteLine(); var schemaStr = "new SequenceSchema(false, " + Environment.NewLine + string.Join("," + Environment.NewLine, def.Fields.Select(f => cls.IndentString(1) + "new FieldSchema(\"" + _transformFieldName(f.Name) + "\", " + f.Tag + ", Value<" + _sequenceFieldTypeName(f) + ">.Schema)").ToArray()) + ")"; cls.StaticReadonlyField("Schema", "ISchema", schemaStr, @new: !string.IsNullOrEmpty(choiceBase)); cls.WriteLine(); using (var load = cls.StaticMethod("Load", typeName, new Parameter[] { new Parameter("IValueStream", "stream") }, @new: !string.IsNullOrEmpty(choiceBase))) { load.WriteLine("stream.EnterSequence();"); foreach (var field in def.Fields) { load.WriteLine("var {0} = Value<{1}>.Load(stream);", _fieldNameToTempName(field.Name), _sequenceFieldTypeName(field)); } load.WriteLine("stream.LeaveSequence();"); load.WriteLine("return new " + typeName + "(" + string.Join(", ", def.Fields.Select(f => _fieldNameToTempName(f.Name)).ToArray()) + ");"); } cls.WriteLine(); using (var save = cls.StaticMethod("Save", "void", new Parameter[] { new Parameter("IValueSink", "sink"), new Parameter(typeName, "value") })) { save.WriteLine("sink.EnterSequence();"); foreach (var field in def.Fields) { save.WriteLine("Value<{0}>.Save(sink, value.{1});", _sequenceFieldTypeName(field), _transformFieldName(field.Name)); } save.WriteLine("sink.LeaveSequence();"); } if (root) { _generateSequenceFields(cls, def); } } if (!root) { _generateSequenceFields(emitter, def); } }
private static string GetSchema(DbModel model, SequenceDefinition sequence) { return(sequence.ExplicitSchema ?? model.Config.GetSchema(sequence.Module.Area)); }
public DbSequenceInfo(DbModel model, SequenceDefinition definition) : base(model, GetSchema(model, definition), DbObjectType.Sequence, definition) { Name = definition.Name; DbType = model.Driver.TypeRegistry.GetDbTypeInfo(definition.DataType, 0); StartValue = definition.StartValue; Increment = definition.Increment; Definition = definition; FullName = model.Driver.GetFullName(Schema, Name); }
public static void ThrowIfInvalid(this SequenceDefinition def) { ((BaseDefinition)def).ThrowIfInvalid(); // currently sequences don't have anything to validate }
public CreateSequenceExpression() { Sequence = new SequenceDefinition(); }
public override void Apply(AttributeContext context, Attribute attribute, EntityMemberInfo member) { _member = member; var entity = member.Entity; member.Flags |= EntityMemberFlags.AutoValue; member.AutoValueType = this.Type; switch (this.Type) { case AutoType.Identity: entity.Flags |= EntityFlags.HasIdentity; member.Flags |= EntityMemberFlags.Identity | EntityMemberFlags.NoDbInsert | EntityMemberFlags.NoDbUpdate; //Usually identity is int (or long). But there are some wierd real-life databases with Numeric (Decimal) identity columns // apparently MS SQL allows this var intOrDec = member.DataType.IsInt() || member.DataType == typeof(Decimal); if (!intOrDec) { context.Log.Error("Entity member {0}.{1}, type {2}: Identity attribute may be set only on member of integer or decimal types. ", _member.Entity, _member.MemberName, this.Type); return; } entity.Events.New += EntityEvent_NewEntityHandleIdentity; entity.SaveEvents.SubmittedChanges += EntityEvent_IdentityEntitySubmitted; break; case AutoType.Sequence: if (!member.DataType.IsInt()) { context.Log.Error("Entity member {0}.{1}, type {2}: Sequence attribute may be set only on member of integer types. ", _member.Entity, _member.MemberName, this.Type); return; } if (string.IsNullOrWhiteSpace(SequenceName)) { context.Log.Error("Entity member {0}.{1}: Sequence name must be specified.", _member.Entity, _member.MemberName); return; } _sequence = context.Model.FindSequence(SequenceName, entity.Module); if (_sequence == null) { context.Log.Error("Entity member {0}.{1}: Sequence {0} not defined.", _member.Entity, _member.MemberName, this.SequenceName); return; } if (_sequence.DataType != member.DataType) { context.Log.Error("Entity member {0}.{1}: data type {2} does not match sequence '{3}' data type {4}.", _member.Entity, _member.MemberName, _member.DataType, this.SequenceName, _sequence.DataType); return; } entity.Events.New += EntityEvent_NewEntityHandleSequence; break; case AutoType.NewGuid: if (!CheckDataType(context, typeof(Guid))) return; entity.Events.New += EntityEvent_HandleNewGuid; break; case AutoType.CreatedOn: case AutoType.UpdatedOn: if (!CheckDataType(context, typeof(DateTime), typeof(DateTimeOffset))) return; if (this.Type == AutoType.CreatedOn) member.Flags |= EntityMemberFlags.NoDbUpdate; if (member.DataType == typeof(DateTime) || member.DataType == typeof(DateTime?)) entity.SaveEvents.SavingChanges += EntityEvent_HandleCreatedUpdatedOnDateTime; else entity.SaveEvents.SavingChanges += EntityEvent_HandleCreatedUpdatedOnDateTimeOffset; break; case AutoType.CreatedBy: if (!CheckDataType(context, typeof(string))) return; entity.Events.New += EntityEvent_HandleUpdatedCreatedBy; member.Flags |= EntityMemberFlags.NoDbUpdate; break; case AutoType.UpdatedBy: if (!CheckDataType(context, typeof(string))) return; entity.Events.New += EntityEvent_HandleUpdatedCreatedBy; entity.Events.Modified += EntityEvent_HandleUpdatedCreatedBy; break; case AutoType.CreatedById: entity.Events.New += EntityEvent_HandleUpdatedCreatedById; member.Flags |= EntityMemberFlags.NoDbUpdate; break; case AutoType.UpdatedById: entity.Events.New += EntityEvent_HandleUpdatedCreatedById; entity.Events.Modified += EntityEvent_HandleUpdatedCreatedById; break; case AutoType.RowVersion: member.Flags |= EntityMemberFlags.RowVersion | EntityMemberFlags.NoDbInsert | EntityMemberFlags.NoDbUpdate; member.Entity.Flags |= EntityFlags.HasRowVersion; member.ExplicitDbTypeSpec = "timestamp"; break; }//swith AutoValueType }