精华内容
下载资源
问答
  • Kotlin 中的序列(Sequences) 序列(Sequences)实际上是对应 Java8 中的 Stream 的翻版。从之前文章可以了解到 Kotlin 定义了很多操作集合的 API,没错这些函数照样适用于序列(Sequences),而且序列操作在性能...

    Kotlin 中的序列(Sequences)

    序列(Sequences)实际上是对应 Java8 中的 Stream 的翻版。从之前文章可以了解到 Kotlin 定义了很多操作集合的 API,没错这些函数照样适用于序列(Sequences),而且序列操作在性能方面优于集合操作。而且通过之前函数式 API 的源码中可以看出它们会创建很多中间集合,每个操作符都会开辟内存来存储中间数据集,然而这些在序列中就不需要。

    1. 为什么需要 Sequences

    我们一般在 Kotlin 中处理数据集都是集合,以及使用集合中一些函数式操作符 API,我们很少去将数据集转换成序列再去做集合操作。这是因为我们一般接触的数据量级比较小,使用集合和序列没什么差别,让我们一起来看个例子,你就会明白使用序列的意义了。

    //不使用Sequences序列,使用普通的集合操作
    fun computeRunTime(action: (() -> Unit)?) {
      val startTime = System.currentTimeMillis()
      action?.invoke()
      println("the code run time is ${System.currentTimeMillis() - startTime}")
    }
    
    fun main(args: Array<String>) = computeRunTime {
      (0..10000000)
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .count { it < 10 }
            .run {
                println("by using list way, result is : $this")
            }
    }

    运行结果

    by using list way, result is : 4
    the code run time is 3173
    //转化成Sequences序列,使用序列操作
    fun computeRunTime(action: (() -> Unit)?) {
        val startTime = System.currentTimeMillis()
        action?.invoke()
        println("the code run time is ${System.currentTimeMillis() - startTime}")
    }
    
    fun main(args: Array<String>) = computeRunTime {
        (0..10000000)
            .asSequence()
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .count { it < 10 }
            .run {
                println("by using sequences way, result is : $this")
            }
    }

    运行结果

    by using list way, result is : 4
    the code run time is 47

    通过以上同一个功能实现,使用普通集合操作和转化成序列后再做操作的运行时间差距不仅一点点,也就对应着两种实现方式在数据集量级比较大的情况下,性能差异也是很大的。这样应该知道为什么我们需要使用 Sequences 序列了吧。

    2. 什么是 Sequences

    序列操作又被称之为惰性集合操作,Sequences 序列接口强大在于其操作的实现方式。序列中的元素求值都是惰性的,所以可以更加高效使用序列来对数据集中的元素进行链式操作 (映射、过滤、变换等), 而不需要像普通集合那样,每进行一次数据操作,都必须要开辟新的内存来存储中间结果,而实际上绝大多数的数据集合操作的需求关注点在于最后的结果而不是中间的过程,

    序列是在 Kotlin 中操作数据集的另一种选择,它和 Java8 中新增的 Stream 很像,在 Java8 中我们可以把一个数据集合转换成 Stream,然后再对 Stream 进行数据操作 (映射、过滤、变换等),序列 (Sequences) 可以说是用于优化集合在一些特殊场景下的工具。但是它不是用来替代集合,准确来说它起到是一个互补的作用。

    序列操作分为两大类:

    1、中间操作

    序列的中间操作始终都是惰性的,一次中间操作返回的都是一个序列 (Sequences),产生的新序列内部知道如何变换原始序列中的元素。怎样说明序列的中间操作是惰性的呢?一起来看个例子:

    fun main(args: Array<String>) {
        (0..6)
            .asSequence()
            .map {//map返回是Sequence<T>,故它属于中间操作
                println("map: $it")
                return@map it + 1
            }
            .filter {//filter返回是Sequence<T>,故它属于中间操作
                println("filter: $it")
                return@filter it % 2 == 0
            }
    }
    

    运行结果

    Process finished with exit code 0

    以上例子只有中间操作没有末端操作,通过运行结果发现 map、filter 中并没有输出任何提示,这也就意味着 map 和 filter 的操作被延迟了,它们只有在获取结果的时候 (也即是末端操作被调用的时候) 才会输出提示

    2、末端操作

    序列的末端操作会执行原来中间操作的所有延迟计算,一次末端操作返回的是一个结果,返回的结果可以是集合、数字、或者从其他对象集合变换得到任意对象。上述例子加上末端操作:

    fun main(args: Array<String>) {
        (0..6)
            .asSequence()
            .map {//map返回是Sequence<T>,故它属于中间操作
                println("map: $it")
                return@map it + 1
            }
            .filter {//filter返回是Sequence<T>,故它属于中间操作
                println("filter: $it")
                return@filter it % 2 == 0
            }
            .count {//count返回是Int,返回的是一个结果,故它属于末端操作
                it < 6
            }
            .run {
                println("result is $this");
            }
    }
    

    运行结果

    map: 0
    filter: 1
    map: 1
    filter: 2
    map: 2
    filter: 3
    map: 3
    filter: 4
    map: 4
    filter: 5
    map: 5
    filter: 6
    map: 6
    filter: 7
    result is 2
    
    Process finished with exit code 0
    

    注意:判别是否是中间操作还是末端操作很简单,只需要看操作符 API 函数返回值的类型,如果返回的是一个 Sequence 那么这就是一个中间操作,如果返回的是一个具体的结果类型,比如 Int,Boolean, 或者其他任意对象,那么它就是一个末端操作

    3. 怎么创建 Sequences

    创建序列(Sequences)的方法主要有:

    1、使用 Iterable 的扩展函数 asSequence 来创建

    //定义声明
    public fun <T> Iterable<T>.asSequence(): Sequence<T> {
        return Sequence { this.iterator() }
    }
    //调用实现
    list.asSequence()
    

    2、使用 generateSequence 函数生成一个序列

    //定义声明
    @kotlin.internal.LowPriorityInOverloadResolution
    public fun <T : Any> generateSequence(seed: T?, nextFunction: (T) -> T?): Sequence<T> =
        if (seed == null)
            EmptySequence
        else
            GeneratorSequence({ seed }, nextFunction)
    
    //调用实现,seed是序列的起始值,nextFunction迭代函数操作
    val naturalNumbers = generateSequence(0) { it + 1 } //使用迭代器生成一个自然数序列
    

    3、使用序列 (Sequence) 的扩展函数 constrainOnce 生成一次性使用的序列。

    //定义声明
    public fun <T> Sequence<T>.constrainOnce(): Sequence<T> {
        // as? does not work in js
        //return this as? ConstrainedOnceSequence<T> ?: ConstrainedOnceSequence(this)
        return if (this is ConstrainedOnceSequence<T>) this else ConstrainedOnceSequence(this)
    }
    //调用实现
    val naturalNumbers = generateSequence(0) { it + 1 }
    val naturalNumbersOnce = naturalNumbers.constrainOnce()
    

    注意:只能迭代一次,如果超出一次则会抛出 IllegalStateException (“This sequence can be consumed only once.”) 异常。

    4. Sequences 操作和集合操作性能对比

    关于序列性能对比,主要在以下几个场景下进行对比,通过性能对比你就清楚在什么场景下该使用普通集合操作还是序列操作。

    在数据量级比较大情况下使用 Sequences 序列性能会比普通数据集合更优;但是在数据量级比较小情况下使用 Sequences 序列性能反而会比普通数据集合更差。

    5. Sequences 性能优化的原理

    看到上面性能的对比,相信此刻的你迫不及待想要知道序列 (Sequences) 内部性能优化的原理吧,那么我们一起来看下序列内部的原理。来个例子

    fun main(args: Array<String>){
        (0..10)
            .asSequence()
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .count { it < 6 }
            .run {
                println("by using sequence result is $this")
            }
    }
    

    1、基本原理描述

    序列操作 :基本原理是惰性求值,也就是说在进行中间操作的时候,是不会产生中间数据结果的,只有等到进行末端操作的时候才会进行求值。也就是上述例子中 0~10 中的每个数据元素都是先执行 map 操作,接着马上执行 filter 操作。然后下一个元素也是先执行 map 操作,接着马上执行 filter 操作。然而普通集合是所有元素都完执行 map 后的数据存起来,然后从存储数据集中又所有的元素执行 filter 操作存起来的原理。

    集合普通操作 :针对每一次操作都会产生新的中间结果,也就是上述例子中的 map 操作完后会把原始数据集循环遍历一次得到最新的数据集存放在新的集合中,然后进行 filter 操作,遍历上一次 map 新集合中数据元素,最后得到最新的数据集又存在一个新的集合中。

    2、原理图解

    //使用序列
    fun main(args: Array<String>){
        (0..100)
            .asSequence()
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .find { it > 3 }
    }
    //使用普通集合
    fun main(args: Array<String>){
        (0..100)
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .find { it > 3 }
    }
    

    通过以上的原理转化图,会发现使用序列会逐个元素进行操作,在进行末端操作 find 获得结果之前提早去除一些不必要的操作,以及 find 找到一个符合条件元素后,后续众多元素操作都可以省去,从而达到优化的目的。而集合普通操作,无论是哪个元素都得默认经过所有的操作。其实有些操作在获得结果之前是没有必要执行的以及可以在获得结果之前,就能感知该操作是否符合条件,如果不符合条件提前摒弃,避免不必要操作带来性能的损失。

    6. Sequences 原理源码完全解析

    //使用序列
    fun main(args: Array<String>){
        (0..100)
            .asSequence()
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .find { it > 3 }
    }
    //使用普通集合
    fun main(args: Array<String>){
        (0..100)
            .map { it + 1 }
            .filter { it % 2 == 0 }
            .find { it > 3 }
    }
    

    通过 decompile 上述例子的源码会发现,普通集合操作会针对每个操作都会生成一个 while 循环,并且每次都会创建新的集合保存中间结果。而使用序列则不会,它们内部会无论进行多少中间操作都是共享同一个迭代器中的数据,想知道共享同一个迭代器中的数据的原理吗?请接着看内部源码实现。

    6.1 使用集合普通操作反编译源码

     public static final void main(@NotNull String[] args) {
          Intrinsics.checkParameterIsNotNull(args, "args");
          byte var1 = 0;
          Iterable $receiver$iv = (Iterable)(new IntRange(var1, 100));
          //创建新的集合存储map后中间结果
          Collection destination$iv$iv = (Collection)(new ArrayList(CollectionsKt.collectionSizeOrDefault($receiver$iv, 10)));
          Iterator var4 = $receiver$iv.iterator();
    
          int it;
          //对应map操作符生成一个while循环
          while(var4.hasNext()) {
             it = ((IntIterator)var4).nextInt();
             Integer var11 = it + 1;
             //将map变换的元素加入到新集合中
             destination$iv$iv.add(var11);
          }
    
          $receiver$iv = (Iterable)((List)destination$iv$iv);
          //创建新的集合存储filter后中间结果
          destination$iv$iv = (Collection)(new ArrayList());
          var4 = $receiver$iv.iterator();//拿到map后新集合中的迭代器
          //对应filter操作符生成一个while循环
          while(var4.hasNext()) {
             Object element$iv$iv = var4.next();
             int it = ((Number)element$iv$iv).intValue();
             if (it % 2 == 0) {
              //将filter过滤的元素加入到新集合中
                destination$iv$iv.add(element$iv$iv);
             }
          }
    
          $receiver$iv = (Iterable)((List)destination$iv$iv);
          Iterator var13 = $receiver$iv.iterator();//拿到filter后新集合中的迭代器
          
          //对应find操作符生成一个while循环,最后末端操作只需要遍历filter后新集合中的迭代器,取出符合条件数据即可。
          while(var13.hasNext()) {
             Object var14 = var13.next();
             it = ((Number)var14).intValue();
             if (it > 3) {
                break;
             }
          }
       }
    

    6.2 使用序列 (Sequences) 惰性操作反编译源码

    1、整个序列操作源码

     public static final void main(@NotNull String[] args) {
          Intrinsics.checkParameterIsNotNull(args, "args");
          byte var1 = 0;
          //利用Sequence扩展函数实现了fitler和map中间操作,最后返回一个Sequence对象。
          Sequence var7 = SequencesKt.filter(SequencesKt.map(CollectionsKt.asSequence((Iterable)(new IntRange(var1, 100))), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
          //取出经过中间操作产生的序列中的迭代器,可以发现进行map、filter中间操作共享了同一个迭代器中数据,每次操作都会产生新的迭代器对象,但是数据是和原来传入迭代器中数据共享,最后进行末端操作的时候只需要遍历这个迭代器中符合条件元素即可。
          Iterator var3 = var7.iterator();
          //对应find操作符生成一个while循环,最后末端操作只需要遍历filter后新集合中的迭代器,取出符合条件数据即可。
          while(var3.hasNext()) {
             Object var4 = var3.next();
             int it = ((Number)var4).intValue();
             if (it > 3) {
                break;
             }
          }
    
       }
    

    2、抽出其中这段关键 code,继续深入:

    SequencesKt.filter(SequencesKt.map(CollectionsKt.asSequence((Iterable)(new IntRange(var1, 100))), (Function1)null.INSTANCE), (Function1)null.INSTANCE);
    

    3、把这段代码转化分解成三个部分:

    //第一部分
    val collectionSequence = CollectionsKt.asSequence((Iterable)(new IntRange(var1, 100)))
    //第二部分
    val mapSequence = SequencesKt.map(collectionSequence, (Function1)null.INSTANCE)
    //第三部分
    val filterSequence = SequencesKt.filter(mapSequence, (Function1)null.INSTANCE)
    

    4、解释第一部分代码:

    第一部分反编译的源码很简单,主要是调用 Iterable 中扩展函数将原始数据集转换成 Sequence 对象

    public fun <T> Iterable<T>.asSequence(): Sequence<T> {
        return Sequence { this.iterator() }//传入外部Iterable<T>中的迭代器对象
    }
    

    更深入一层

    @kotlin.internal.InlineOnly
    public inline fun <T> Sequence(crossinline iterator: () -> Iterator<T>): Sequence<T> = object : Sequence<T> {
        override fun iterator(): Iterator<T> = iterator()
    }
    

    通过外部传入的集合中的迭代器方法返回迭代器对象,通过一个对象表达式实例化一个 Sequence,Sequence 是一个接口,内部有个 iterator () 抽象函数返回一个迭代器对象,然后把传入迭代器对象作为 Sequence 内部的迭代器,也就是相当于给迭代器加了 Sequence 序列的外壳,核心迭代器还是由外部传入的迭代器对象,有点偷梁换柱的概念。

    5、解释第二部分的代码

    通过第一部分,成功将普通集合转换成序列 Sequence,然后现在进行 map 操作,实际上调用了 Sequence 扩展函数 map 来实现的

    val mapSequence = SequencesKt.map(collectionSequence, (Function1)null.INSTANCE)
    

    进入 map 扩展函数

    public fun <T, R> Sequence<T>.map(transform: (T) -> R): Sequence<R> {
        return TransformingSequence(this, transform)
    }
    

    会发现内部会返回一个 TransformingSequence 对象,该对象构造器接收一个 Sequence 类型对象,和一个 transform 的 lambda 表达式,最后返回一个 Sequence 类型对象。我们先暂时解析到这,后面会更加介绍。

    6、解释第三部分的代码:

    通过第二部分,进行 map 操作后,然后返回的还是 Sequence 对象,最后再把这个对象进行 filter 操作,filter 也还是 Sequence 的扩展函数,最后返回还是一个 Sequence 对象

    val filterSequence = SequencesKt.filter(mapSequence, (Function1)null.INSTANCE)
    

    进入 filter 扩展函数

    public fun <T> Sequence<T>.filter(predicate: (T) -> Boolean): Sequence<T> {
        return FilteringSequence(this, true, predicate)
    }
    

    会发现内部会返回一个 FilteringSequence 对象,该对象构造器接收一个 Sequence 类型对象,和一个 predicate 的 lambda 表达式,最后返回一个 Sequence 类型对象。我们先暂时解析到这,后面会更加介绍。

    7、Sequences 源码整体结构介绍

    代码结构图 :图中标注的都是一个个对应各个操作符类,它们都实现 Sequence 接口

    首先,Sequence 是一个接口,里面只有一个抽象函数,一个返回迭代器对象的函数,可以把它当做一个迭代器对象外壳。

    public interface Sequence<out T> {
        /**
         * Returns an [Iterator] that returns the values from the sequence.
         *
         * Throws an exception if the sequence is constrained to be iterated once and `iterator` is invoked the second time.
         */
        public operator fun iterator(): Iterator<T>
    }
    

    Sequence 核心类 UML 类图

    这里只画出了某几个常用操作符的类图

    注意:通过上面的 UML 类关系图可以得到,共享同一个迭代器中的数据的原理实际上就是利用 Java 设计模式中的状态模式 (面向对象的多态原理) 来实现的,首先通过 Iterable 的 iterator () 返回的迭代器对象去实例化 Sequence,然后外部调用不同的操作符,这些操作符对应着相应的扩展函数,扩展函数内部针对每个不同操作返回实现 Sequence 接口的子类对象,而这些子类又根据不同操作的实现,更改了接口中 iterator () 抽象函数迭代器的实现,返回一个新的迭代器对象,但是迭代的数据则来源于原始迭代器中。

    8、接着上面 TransformingSequence、FilteringSequence 继续解析

    通过以上对 Sequences 整体结构深入分析,那么接着 TransformingSequence、FilteringSequence 继续解析就非常简单了。我们就以 TransformingSequence 为例

    //实现了Sequence<R>接口,重写了iterator()方法,重写迭代器的实现
    internal class TransformingSequence<T, R>
    constructor(private val sequence: Sequence<T>, private val transformer: (T) -> R) : Sequence<R> {
        override fun iterator(): Iterator<R> = object : Iterator<R> {//根据传入的迭代器对象中的数据,加以操作变换后,构造出一个新的迭代器对象。
            val iterator = sequence.iterator()//取得传入Sequence中的迭代器对象
            override fun next(): R {
                return transformer(iterator.next())//将原来的迭代器中数据元素做了transformer转化传入,共享同一个迭代器中的数据。
            }
    
            override fun hasNext(): Boolean {
                return iterator.hasNext()
            }
        }
    
        internal fun <E> flatten(iterator: (R) -> Iterator<E>): Sequence<E> {
            return FlatteningSequence<T, R, E>(sequence, transformer, iterator)
        }
    }
    

    9、源码分析总结

    序列内部的实现原理是采用状态设计模式,根据不同的操作符的扩展函数,实例化对应的 Sequence 子类对象,每个子类对象重写了 Sequence 接口中的 iterator () 抽象方法,内部实现根据传入的迭代器对象中的数据元素,加以变换、过滤、合并等操作,返回一个新的迭代器对象。这就能解释为什么序列中工作原理是逐个元素执行不同的操作,而不是像普通集合所有元素先执行 A 操作,再所有元素执行 B 操作。这是因为序列内部始终维护着一个迭代器,当一个元素被迭代的时候,就需要依次执行 A,B,C 各个操作后,如果此时没有末端操作,那么值将会存储在 C 的迭代器中,依次执行,等待原始集合中共享的数据被迭代完毕,或者不满足某些条件终止迭代,最后取出 C 迭代器中的数据即可。

    7. 总结

    到这里有关 Kotlin 中的序列就阐述完毕了,我们从为什么需要序列到如何使用序列以及最后序列本质是什么多个角度来分析了 Kotlin 中的序列,相信大家对 Kotlin 序列有了很深的印象

     

    展开全文
  • //get sequence last_number SELECT LAST_NUMBER FROM USER_SEQUENCES WHERE SEQUENCE_NAME=TEST_SEQNAME // NEXTVAL 使游标指向下一位(增一或减一) SELECT SEQNAME.NEXTVAL FROM USER_SEQUENCES 得到下一位游标...

    Oracle提供了sequence对象,由系统提供自增长的序列号,通常用于生成数据库数据记录的自增长主键或序号的地方.

    Oracle提供了sequence对象,由系统提供自增长的序列号,通常用于生成数据库数据记录的自增长主键或序号的地方.

    下面介绍一下关于sequence 的生成,修改,删除等常用的操作:

    1. 创建 Sequence

    使用如下命令新建sequence(用户需要有CREATE SEQUENCE 或者CREATE ANY SEQUENCE权限):

    CREATE SEQUENCE test_sequence

    INCREMENT BY 1   -- 每次加的个数据

    START WITH 1    -- 从1开始计数

    NOMAXVALUE    -- 不设置最大值

    NOCYCLE      -- 一直累加,不循环

    CACHE 10 ;

    [注意]

    如果设置了CACHE值,ORACLE将在内存里预先放置一些sequence,以使存取速度更快。cache里面的取完后,oracle自动再取一组到cache。 但是,使用cache可能会跳号, 当遇到数据库突然异常down掉(shutdown abort),cache中的sequence就会丢失.

    因此,推荐在create sequence的时候使用 nocache 选项。

    2. 使用 sequence:

    sequence.CURRVAL -- 返回 sequence的当前值

    sequence.NEXTVAL -- 增加sequence的值,然后返回 sequence 值

    [注意]

    第一次NEXTVAL返回的是初始值;

    随后的NEXTVAL会自动增加你定义的INCREMENT BY值,然后返回增加后的值。

    CURRVAL 总是返回当前SEQUENCE的值,但是在第一次NEXTVAL初始化之后才能使用CURRVAL,,否则会出错。

    一次NEXTVAL会增加一次 SEQUENCE的值,所以如果你在同一个语句里面使用多个NEXTVAL,其值就是不一样的。

    sequence 存储在数据字典中,存储于user_sequences表

    LAST_NUMBER 为最终序列号,也就是sequence游标当前所在的位置。

    //get sequence last_number

    SELECT LAST_NUMBER FROM USER_SEQUENCES WHERE SEQUENCE_NAME=TEST_SEQNAME

    // NEXTVAL 使游标指向下一位(增一或减一)

    SELECT SEQNAME.NEXTVAL FROM USER_SEQUENCES 得到下一位游标的值

    3. 修改 Sequence

    用户必须拥有ALTER ANY SEQUENCE 权限才能修改sequence. 可以alter除start至以外的所有sequence参数.

    如果想要改变start值,必须 drop sequence 再 re-create.

    命令格式如下:

    ALTER SEQUENCE test_sequence

    INCREMENT BY 10

    MAXVALUE 10000

    CYCLE    -- 到10000后从头开始

    NOCACHE ;

    4. 删除 Sequence

    DROP SEQUENCE order_seq;

    更多Oracle相关信息见Oracle 专题页面 ?tid=12

    logo.gif

    f68f2add0b68e4f9810432fce46917b7.png

    本文原创发布php中文网,转载请注明出处,感谢您的尊重!

    展开全文
  • Stopping - all 545 input sequences aligned poorly to reference sequences (--min_align option specified a minimum proportion of 0.8 aligning to reference sequences). 需要对otu.fa取反向 再进行分析 ...

    在用picrust2做功能预测是时出现

    Stopping - all 545 input sequences aligned poorly to reference sequences (--min_align option specified a minimum proportion of 0.8 aligning to reference sequences).
    

    需要对otu.fa取反向
    再进行分析

    seqtk seq -r otus.fa >otus_rc.fa
    
    展开全文
  • //get sequence last_number SELECT LAST_NUMBER FROM USER_SEQUENCES WHERE SEQUENCE_NAME=TEST_SEQNAME // NEXTVAL 使游标指向下一位(增一或减一) SELECT SEQNAME.NEXTVAL FROM USER_SEQUENCES 得到下一位游标...

    Oracle提供了sequence对象,由系统提供自增长的序列号,用于生成数据库数据记录的自增长主键或序号的地方。如果当前的序列不存在,它会创建一个序列,如果存在,它首先要得到当前序列的最大值,然后再加一,实现自增长的功能。

    创建序列命令

    CREATE SEQUENCE [user.]sequence_name
    [increment by n]
    [start with n]
    [maxvalue n | nomaxvalue]
    [minvalue n | nominvalue];
    [NOCYCLE]
    

    INCREMENT BY: 指定序列号之间的间隔,该值可为正的或负的整数,但不可为0。序列为升序。忽略该子句时,缺省值为1。

    START WITH:指定生成的第一个序列号。在升序时,序列可从比最小值大的值开始,缺省值为序列的最小值。对于降序,序列可由比最大值小的值开始,缺省值为序列的最大值。

    MAXVALUE:指定序列可生成的最大值。

    NOMAXVALUE:为升序指定最大值为1027,为降序指定最大值为-1。

    MINVALUE:指定序列的最小值。

    NOMINVALUE:为升序指定最小值为1。为降序指定最小值为-1026。

    NOCYCLE:一直累加,不循环。

    需要注意的是,cache的作用是当大量语句发生请求,申请序列时,为了避免序列在运用层实现序列而引起的性能瓶颈。Oracle序列允许将序列提前生成 cache x个先存入内存,在发生大量申请序列语句时,可直接到运行最快的内存中去得到序列。但是如果设置了CACHE值,ORACLE将在内存里预先放置一些sequence,以使存取速度更快。cache里面的取完后,oracle自动再取一组到cache。 但是,使用cache可能会跳号, 当遇到数据库突然异常down掉(shutdown abort),cache中的sequence就会丢失.
    因此,推荐在create sequence的时候使用 nocache 选项。

    修改序列命令

    用户必须拥有ALTER ANY SEQUENCE 权限才能修改sequence. 可以alter除start至以外的所有sequence参数.
    如果想要改变start值,必须 drop sequence 再 re-create.
    语法如下:

    ALTERSEQUENCE [user.]sequence_name
    [INCREMENT BY n]
    [MAXVALUE n| NOMAXVALUE ]
    [MINVALUE n | NOMINVALUE]

    当然,最方便的还是可以在PLSQL Developer中直接修改。可以修改未来序列值的增量;设置或撤消最小值或最大值;改变缓冲序列的数目;指定序列号是否是有序。

    使用序列命令

    sequence.CURRVAL – 返回 sequence的当前值
    sequence.NEXTVAL – 增加sequence的值,然后返回 sequence 值
    [注意]
    第一次NEXTVAL返回的是初始值;
    随后的NEXTVAL会自动增加你定义的INCREMENT BY值,然后返回增加后的值。
    CURRVAL 总是返回当前SEQUENCE的值,但是在第一次NEXTVAL初始化之后才能使用CURRVAL,否则会出错。
    一次NEXTVAL会增加一次 SEQUENCE的值,所以如果你在同一个语句里面使用多个NEXTVAL,其值就是不一样的。
    LAST_NUMBER 为最终序列号,也就是sequence游标当前所在的位置。
    //get sequence last_number
    SELECT LAST_NUMBER FROM USER_SEQUENCES WHERE SEQUENCE_NAME=TEST_SEQNAME
    // NEXTVAL 使游标指向下一位(增一或减一)
    SELECT SEQNAME.NEXTVAL FROM USER_SEQUENCES 得到下一位游标的值

    删除序列命令

    DROP SEQUENCE 序列名;

    To be continued…

    展开全文
  • oracle导出sequences

    2021-05-01 03:40:00
    ' from dba_sequences where sequence_owner='SCOTT' PS::其中SCOTT是需要导出sequence的用户,并且使用该脚本的用户需要有访问dba_sequences的权限。 将本用户下全部sequence查询出来,并拼成创建语句: select '...
  • def build_model(): NUM_MIDDLE_01 = 100 ... model.add(LSTM(NUM_MIDDLE_01, input_shape=(train_x.shape[1], train_x.shape[2]) ,return_sequences=True)) # model.add(LSTM(NUM_MIDDLE_01, input_shape=(NUM_.
  • training sequences

    2021-03-17 11:20:02
    training sequences由order sets组成,用来实现bit对齐、symbol对齐和交换物理层参数.
  • 序列:USER_SEQUENCES(SEQ) 要显示序列的属性,可以查询USER_SEQUENCES 数据字典视图。该视图也能用公有同义词SEQ 进行查询。USER_SEQUENCES 视图的列如下所示: Sequence_Name 序列名 Min_Value 序列的最小值 Max_...
  • counts) X = pad_sequences(x, maxlen=max_len) Y = pad_sequences(y, maxlen=max_len) 仔细检查后,我发现我的填充序列看起来像这样 >>> X[0:6] array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...
  • oracle序列sequences

    2021-04-30 11:48:11
    想了解一个已存在的序列信息可以通过数据字典的dba_sequences、all_sequences、user_sequences等几个视图来查看。 修改一个已存在的序列利用sql命令alert sequence来实现 例如,想修改序列stuenno的cache属性为30且...
  • 多序列比对(multiple sequences alignment,MSA)是开展进化生物学研究的前提,后续可以进行选择压力分析以及推断物种系统发育历史。 多序列比对表示不同序列中的氨基酸/核苷酸的位点同源性。将序列比对用于进化...
  • 文章目录 Multimodal Transformer for Unaligned Multimodal Language Sequences Summary 摘要 (中文) Research Objective Background and Problems main work Related work Method(s) Conclusion Reference...
  • keras只能接受长度相同的序列输入。数据处理需要使用pad_sequences(),将序列转化为经过填充以后的一个长度相同的新序列。 语法结构: keras.preprocessing.sequence.pad_sequences(sequences, maxl
  • Learning Temporal Regularity in Video Sequences CVPR2016 无监督视频异常事件检测早期工作 摘要 由于对“有意义”的定义不明确以及场景混乱,因此在较长的视频序列中感知有意义的活动是一个具有挑战性的问题。...
  • 目录 Summary Details 1、Task 2、The proposed Order Prediction Network(OPN) 3、Data sampling ...论文名称:Unsupervised Representation Learning by Sorting Sequences 下载地址:https://openacce..
  • [论文记录] 2019 - Multimodal Transformer for Unaligned Multimodal Language Sequences论文简介论文内容摘要1 介绍 论文简介 原论文:Multimodal Transformer for Unaligned Multimodal Language Sequences1 ...
  • , trainable=False)) model.add(SpatialDropout1D(0.55)) # return_sequences: 布尔值。是返回输出序列中的最后一个输出,还是全部序列,默认false。 model.add(LSTM(128, dropout=0.2, recurrent_dropout=0.2, input...
  • keras.preprocessing.sequence.pad_sequences(sequences, maxlen=None, dtype='int32', padding='pre', truncating='pre', value=0.) sequences: 浮点数或整数构成的两层嵌套列表 maxlen:None或者整数,为...
  • Oracle Sequences

    2021-05-05 00:59:01
    NEXTVAL ---------- 120 SQL> select test_seq.currval from dual CURRVAL ---------- 120 SQL> Oracle Sequences 标签:div efi amp ica number less tar bash line 本条技术文章来源于互联网,如果无意...
  • Homepage URLhttp://flysky-1.at.vwdhosting.netFTP server name:ftp://flysky-1@ftp6.vwdhosting.net Login:flysky-1Password:k%x5WY(0zp? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志...
  • Halton序列 在统计学中,Halton...discrepancy sequences 补充原文 原文中陈述了很多具体的例子,而缺乏了一些Halton序列本身的说明,使用场景、以及与其他序列使用对比的差异,故在此处进行补充,更详细的介绍可参考...
  • 946.Validate Stack Sequences Medium Given two sequencespushedandpoppedwith distinct values,returntrueif and only if this could have been the result of a sequence of push and pop operations on an ...
  • 当训练完一个序列模型之后,我们要想了解到这个模型学到了什么,一种非正式的方法就是进行一次新序列采样(have a samplenovel sequences),来看看到底应该怎么做。 注意序列模型模拟了任意特定单词序列的概率,...
  • MySQL Using Sequences

    2021-03-04 03:14:44
    序列就是按照要求的顺序产生的一组整数,比如1、2、3……这样。数据库中经常会用到序列,因为很多应用程序都会需要让表中的每行的值唯一,而使用序列就可以轻松地解决这个问题。下面就来介绍 MySQL 中的序列使用。...
  • 1. DNA sequences alignment 两个DNA序列如下: sequence_A = "AGGCTATCACCTGACCTCCAGGCCGATGCCC" sequence_B = "TAGCTATCACGACCGCGGTCGATTTGCCCGAC" 2. 对齐代码 import numpy as np import matplotlib.pyplot as ...
  • #include<iostream> #include<cstdio> #include<string> #include<ctime> #include<cmath> #include<cstring> #include<algorithm> #include<...#in
  • 一、定义return_sequences:默认为false。当为false时,返回最后一层最后一个步长的hidden state;当为true时,返回最后一层的所有hidden state。return_state:默认false.当为true时,返回最后一层的最后一个步长的...
  • 题意: 解法: 统计所有数二进制位中0和1的数量, 对于每一个二进制位: 如果为全0或者全1,那么这一位怎么排列都可以, 否则既有0又有1, 此时我们一定要选出两个该二进制位为0的数, 一个放在b[1],一个放在b[n], ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,094
精华内容 30,837
关键字:

Sequences