Example #1
0
        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);
            }
        }
Example #2
0
        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);
        }
Example #3
0
 /// <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);
     }
 }
Example #4
0
 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);
 }
Example #5
0
        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());
        }
Example #7
0
        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);
        }
Example #8
0
 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;
       }
 }
Example #9
0
        }//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;
            }
        }
Example #10
0
        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);
                }
            }
        }
Example #11
0
 public void Truncate(SequenceDefinition sequence)
 {
     sequence.Name = Truncate(sequence.Name);
 }
Example #12
0
 public Sequence(SequenceDefinition definition, Hashtable values)
 {
     this.Definition = definition;
     this.Values     = values;
 }
Example #13
0
 public Sequence(SequenceDefinition definition, ByteStream queue, int contextId)
     :
     this(definition, popStart0(queue, contextId))
 {
     Encodable.popEnd(queue, contextId);
 }
Example #14
0
 private static string GetSchema(DbModel model, SequenceDefinition sequence)
 {
     return sequence.ExplicitSchema ?? model.Config.GetSchema(sequence.Module.Area);
 }
Example #15
0
        /// <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);
            }
        }
Example #16
0
 private static string GetSchema(DbModel model, SequenceDefinition sequence)
 {
     return(sequence.ExplicitSchema ?? model.Config.GetSchema(sequence.Module.Area));
 }
Example #17
0
 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
        }