精华内容
下载资源
问答
  • rows
    千次阅读
    2021-02-16 19:54:54

    PHP中mysqli_affected_rows与mysqli_num_rows的区别

    今天写项目的时候用PHP搭了一个接口用于用户登录注册,登录我是这么写的

    <?php
        $username = $_POST['username'];
        $password = $_POST['password'];
        $con = mysqli_connect('localhost','root','root','hubayi');
        $sql = "select * from users where name='$username' and password='$password'";
        $res = mysqli_query($con,$sql);
        $num = mysqli_num_rows($res);
        if($num > 0) {
            setcookie('login',1,time() + 60 * 60,'/',NULL,NULL);
            $arr = array('error' => 0,'data' => '成功');
        }else {
            $arr = array('error' => 1, 'data' => '失败','text' => $password);
        }
        echo json_encode($arr);
    ?>
    

    在这个文件中我是用mysqli_num_rows获取受影响行数的,这个是没问题的,可以运行,于是我就比着葫芦画瓢,又写了一个注册

    <?php
        $username = $_POST['username'];
    	$password = $_POST['password'];
        $con = mysqli_connect('localhost','root','root','hubayi');
        $sql = "INSERT INTO users(name,password) VALUES('$username','$password')";
        $res = mysqli_query($con,$sql);
        $num = mysqli_affected_rows($res);
        if($num > 0) {
            $arr = array('error' => 0,'data' => '注册成功');
        } else {
            $arr = array('error' => 1,'data' => '注册失败');
        }
        echo json_encode($arr);
    ?>
    

    然而这个代码就给我报错了,

    mysqli_affected_rows() expects parameter 1 to be mysqli, bool given in <b>E:\phpstudy_pro\WWW\link\zhuce.php</b> on line <b>7</b><br />
    

    就是这个错,以前我也遇到过,一般都是sql语句写错了,于是我研究一大会子也没看出来我这个sql语句哪错了,然后我就把mysqli_affected_rows()这个函数换成了mysqli_num_rows,于是又给我报这个错

    mysqli_num_rows() expects parameter 1 to be mysqli_result
    

    然后我就蒙圈了,你说我一个搞前端的,玩儿啥PHP啊,本着一个对代码的热爱还是把这个问题搞明白了。
    mysqli_num_rows()这个函数只用于SELECT查询方法,而mysqli_affected_rows()函数是记录上一个sql语句对整个数据库的影响从而把受影响的数据个数返回,这个主要用于INSERT(插入)、UPDATE(替换)、DELETE(删除)。
    重点来了,这两个函数所需参数不是一样的,我就吃了这个亏,传的都是sql语句执行的结果也就是上边代码的

    $res = mysqli_query($con,$sql);
    

    每次都传res,当然在mysqli_num_rows()是没问题的,因为mysqli_num_rows()需要就是这个结果,但是mysqli_affected_rows()就不一样了,他需要的是$con,也就是

    $con = mysqli_connect('localhost','root','root','hubayi');
    

    他需要一个mysql作为一个参数,就是这个数据库,他需要记录上一个sql语句对整个数据库的影响。以上就是我的理解,龙伏白威!
    对前端感兴趣的小伙伴可以加我QQ:1627889159

    更多相关内容
  • sqlrows sqlrows是一个静态代码分析器,它通过报告sql.Rows使用错误的诊断信息来帮助发现错误。 安装 您可以通过go get命令获取sqlrows 。 $ go get -u github.com/gostaticanalysis/sqlrows 快速开始 当Go为1.12...
  • BootStrapTable行内编辑;压缩包内包含行内编辑所需要的js+css; BootStrapTable行内编辑;压缩包内包含行内编辑所需要的js+css;
  • 本文实例分析了PHP中mysqli_affected_rows作用行数返回值。分享给大家供大家参考。具体分析如下: mysqli中关于update操作...MYSQLI_CLIENT_FOUND_ROWS return number of matched rows, not the number of affected r
  • bootstrap-table-reorder-rows.js ,bootstraptable行拖动
  • 为何sql.Rows使用结束后一定要Close

    千次阅读 2020-11-09 22:48:05
    常见的sql.Rows使用方式如下: var db *sql.DB .... rows, err :=db.QueryContext(ctx,selectSql,args...) ... defer rows.Close() for rows.Next() { if err = rows.Scan(&dst); err != nil { return } } ...

    前言

    常见的sql.Rows使用方式如下:

    var db  *sql.DB
    ....
    rows, err :=db.QueryContext(ctx,selectSql,args...)
    ...
    defer rows.Close()
    for rows.Next() {
    	if err = rows.Scan(&dst); err != nil {
    		return
    	}
    }
    

    我们知道sql.Rows使用结束后一定要关闭。

    但为何要关闭?不关闭又会发生什么呢?

    源码会告诉我们答案。

    Rows

    Rows的结构如下:

    // Rows is the result of a query. Its cursor starts before the first row
    // of the result set. Use Next to advance from row to row.
    type Rows struct {
    	dc          *driverConn // owned; must call releaseConn when closed to release
    	releaseConn func(error)
    	rowsi       driver.Rows
    	cancel      func()      // called when Rows is closed, may be nil.
    	closeStmt   *driverStmt // if non-nil, statement to Close on close
    
    	// closemu prevents Rows from closing while there
    	// is an active streaming result. It is held for read during non-close operations
    	// and exclusively during close.
    	//
    	// closemu guards lasterr and closed.
    	closemu sync.RWMutex
    	closed  bool
    	lasterr error // non-nil only if closed is true
    
    	// lastcols is only used in Scan, Next, and NextResultSet which are expected
    	// not to be called concurrently.
    	lastcols []driver.Value
    }
    

    Rows中的field dc后的注释明确提到了连接关闭释放时一定要调用releaseConn。

    那么releaseConn与Close有什么关联呢?继续看Close的代码。

    Close

    // Close closes the Rows, preventing further enumeration. If Next is called
    // and returns false and there are no further result sets,
    // the Rows are closed automatically and it will suffice to check the
    // result of Err. Close is idempotent and does not affect the result of Err.
    func (rs *Rows) Close() error {
    	return rs.close(nil)
    }
    
    func (rs *Rows) close(err error) error {
    	rs.closemu.Lock()
    	defer rs.closemu.Unlock()
    
    	if rs.closed {
    		return nil
    	}
    	rs.closed = true
    
    	if rs.lasterr == nil {
    		rs.lasterr = err
    	}
    
    	withLock(rs.dc, func() {
    		err = rs.rowsi.Close()
    	})
    	if fn := rowsCloseHook(); fn != nil {
    		fn(rs, &err)
    	}
    	if rs.cancel != nil {
    		rs.cancel()
    	}
    
    	if rs.closeStmt != nil {
    		rs.closeStmt.Close()
    	}
    	rs.releaseConn(err)
    	return err
    }
    

    可以看到Close最后调用的就是releaseConn,到这初步解释了Close的原因,要释放连接。不Close,意味着不释放连接,连接用完后会怎么样呢?

    不Close会发生什么?

    看下sql查询QueryContext的源码:

    // QueryContext executes a prepared query statement with the given arguments
    // and returns the query results as a *Rows.
    func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, error) {
    	s.closemu.RLock()
    	defer s.closemu.RUnlock()
    
    	var rowsi driver.Rows
    	strategy := cachedOrNewConn
    	for i := 0; i < maxBadConnRetries+1; i++ {
    		if i == maxBadConnRetries {
    			strategy = alwaysNewConn
    		}
    		dc, releaseConn, ds, err := s.connStmt(ctx, strategy)
    		if err != nil {
    			if err == driver.ErrBadConn {
    				continue
    			}
    			return nil, err
    		}
    
    		rowsi, err = rowsiFromStatement(ctx, dc.ci, ds, args...)
    		if err == nil {
    			// Note: ownership of ci passes to the *Rows, to be freed
    			// with releaseConn.
    			rows := &Rows{
    				dc:    dc,
    				rowsi: rowsi,
    				// releaseConn set below
    			}
    			// addDep must be added before initContextClose or it could attempt
    			// to removeDep before it has been added.
    			s.db.addDep(s, rows)
    
    			// releaseConn must be set before initContextClose or it could
    			// release the connection before it is set.
    			rows.releaseConn = func(err error) {
    				releaseConn(err)
    				s.db.removeDep(s, rows)
    			}
    			var txctx context.Context
    			if s.cg != nil {
    				txctx = s.cg.txCtx()
    			}
    			rows.initContextClose(ctx, txctx)
    			return rows, nil
    		}
    
    		releaseConn(err)
    		if err != driver.ErrBadConn {
    			return nil, err
    		}
    	}
    	return nil, driver.ErrBadConn
    }
    
    

    rows.releaseConn会调用connStmt生成的releaseConn。

    connStmt

    connStmt的源码如下:

    // connStmt returns a free driver connection on which to execute the
    // statement, a function to call to release the connection, and a
    // statement bound to that connection.
    func (s *Stmt) connStmt(ctx context.Context, strategy connReuseStrategy) (dc *driverConn, releaseConn func(error), ds *driverStmt, err error) {
    	if err = s.stickyErr; err != nil {
    		return
    	}
    	s.mu.Lock()
    	if s.closed {
    		s.mu.Unlock()
    		err = errors.New("sql: statement is closed")
    		return
    	}
    
    	// In a transaction or connection, we always use the connection that the
    	// stmt was created on.
    	if s.cg != nil {
    		s.mu.Unlock()
    		dc, releaseConn, err = s.cg.grabConn(ctx) // blocks, waiting for the connection.
    		if err != nil {
    			return
    		}
    		return dc, releaseConn, s.cgds, nil
    	}
    
    	s.removeClosedStmtLocked()
    	s.mu.Unlock()
    
    	dc, err = s.db.conn(ctx, strategy)
    	if err != nil {
    		return nil, nil, nil, err
    	}
    
    	s.mu.Lock()
    	for _, v := range s.css {
    		if v.dc == dc {
    			s.mu.Unlock()
    			return dc, dc.releaseConn, v.ds, nil
    		}
    	}
    	s.mu.Unlock()
    
    	// No luck; we need to prepare the statement on this connection
    	withLock(dc, func() {
    		ds, err = s.prepareOnConnLocked(ctx, dc)
    	})
    	if err != nil {
    		dc.releaseConn(err)
    		return nil, nil, nil, err
    	}
    
    	return dc, dc.releaseConn, ds, nil
    }
    

    代码虽然很多,只需要关注一行即可(嘚瑟表情):

    dc, releaseConn, err = s.cg.grabConn(ctx) // blocks, waiting for the connection.
    

    看下注释,就可以知道:连接dc及释放连接releaseConn的获取是阻塞的,必须等到有连接时才返回,当数据库的连接用完后,则会一直阻塞至此,表现就是程序运行在此处阻塞。

    这在grabConn的注释中再次提到操作完成后一定要调用release。

    // stmtConnGrabber represents a Tx or Conn that will return the underlying
    // driverConn and release function.
    type stmtConnGrabber interface {
    	// grabConn returns the driverConn and the associated release function
    	// that must be called when the operation completes.
    	grabConn(context.Context) (*driverConn, releaseConn, error)
    
    	// txCtx returns the transaction context if available.
    	// The returned context should be selected on along with
    	// any query context when awaiting a cancel.
    	txCtx() context.Context
    }
    

    总结

    QueryContext查询中会获取一个连接及其对应的连接释放方法(对外即Close),返回的sql.Rows在使用后需要主动调用Close释放连接,否则会因连接占用完毕无法建立新的连接,导致查询阻塞,无法进行sql操作。

    需要注意的是:sql.Row使用就不需要调用Close了,因为其Scan在使用时已经调用了Close方法了。

    func (r *Row) Scan(dest ...interface{}) error {
    	if r.err != nil {
    		return r.err
    	}
    
    
    	defer r.rows.Close()
    	for _, dp := range dest {
    		if _, ok := dp.(*RawBytes); ok {
    			return errors.New("sql: RawBytes isn't allowed on Row.Scan")
    		}
    	}
    
    	if !r.rows.Next() {
    		if err := r.rows.Err(); err != nil {
    			return err
    		}
    		return ErrNoRows
    	}
    	err := r.rows.Scan(dest...)
    	if err != nil {
    		return err
    	}
    	// Make sure the query can be processed to completion with no errors.
    	return r.rows.Close()
    }
    
    展开全文
  • npm install repack-rows --save 用法 var unpack = require ( 'browser-unpack' ) ; var repack = require ( 'repack-rows' ) ; var rows = unpack ( bundle ) ; var main = repack ( rows ) ; repack(rows, ...
  • 看看下面的结果: SQL> select month, 2 sum(tot_sales) month_sales, 3 sum(sum(tot_sales)) over (order by month 4 rows between 1 preceding and unbounded following) all_sales 5 from orders 6 group by ...

    以下转自:(http://blog.csdn.net/huozhicheng/article/details/5843782/)
    作者:Horrison

    目录

    1.窗口函数简介 2.窗口函数示例-全统计 3.窗口函数进阶-滚动统计(累积/均值) 4.窗口函数进阶-根据时间范围统计 5.窗口函数进阶-first_value/last_value 6.窗口函数进阶-比较相邻记录
    一、窗口函数简介:
    到目前为止,我们所学习的分析函数在计算/统计一段时间内的数据时特别有用,但是假如计算/统计需要随着遍历记录集的每一条记录而进行呢?举些例子来说:

    ①列出每月的订单总额以及全年的订单总额
    ②列出每月的订单总额以及截至到当前月的订单总额
    ③列出上个月、当月、下一月的订单总额以及全年的订单总额
    ④列出每天的营业额及一周来的总营业额
    ⑤列出每天的营业额及一周来每天的平均营业额

    仔细回顾一下前面我们介绍到的分析函数,我们会发现这些需求和前面有一些不同:前面我们介绍的分析函数用于计算/统计一个明确的阶段/记录集,而这里有部分需求例如2,需要随着遍历记录集的每一条记录的同时进行统计。

    也即是说:统计不止发生一次,而是发生多次。统计不至发生在记录集形成后,而是发生在记录集形成的过程中。

    这就是我们这次要介绍的窗口函数的应用了。它适用于以下几个场合:

    ①通过指定一批记录:例如从当前记录开始直至某个部分的最后一条记录结束
    ②通过指定一个时间间隔:例如在交易日之前的前30天
    ③通过指定一个范围值:例如所有占到当前交易量总额5%的记

    二、窗口函数示例-全统计:

    下面我们以需求:列出每月的订单总额以及全年的订单总额为例,来看看窗口函数的应用。

    【1】测试环境:

    SQL> desc orders;
     名称                    是否为空? 类型
     ----------------------- -------- ----------------
     MONTH                            NUMBER(2)
     TOT_SALES                    NUMBER
    
    SQL> 
    

    【【2】测试数据:

    SQL> select * from orders;
    
         MONTH  TOT_SALES
    ---------- ----------
             1     610697
             2     428676
             3     637031
             4     541146
             5     592935
             6     501485
             7     606914
             8     460520
             9     392898
            10     510117
            11     532889
            12     492458
    
    已选择12行。
    

    【3】测试语句:

    回忆一下前面《Oracle开发专题之:分析函数(OVER)》一文中,我们使用了sum(sum(tot_sales)) over (partition by region_id) 来统计每个分区的订单总额。现在我们要统计的不单是每个分区,而是所有分区,partition by region_id在这里不起作用了。

    Oracle为这种情况提供了一个子句:rows between ... preceding and ... following。从字面上猜测它的意思是:在XXX之前和XXX之后的所有记录,实际情况如何让我们通过示例来验证:
    SQL> select month,
      2         sum(tot_sales) month_sales,
      3         sum(sum(tot_sales)) over (order by month
      4            rows between unbounded preceding and unbounded following) total_sales
      5    from orders
      6   group by month;
    
         MONTH MONTH_SALES TOTAL_SALES
    ---------- ----------- -----------
             1      610697     6307766
             2      428676     6307766
             3      637031     6307766
             4      541146     6307766
             5      592935     6307766
             6      501485     6307766
             7      606914     6307766
             8      460520     6307766
             9      392898     6307766
            10      510117     6307766
            11      532889     6307766
            12      492458     6307766
    
    已选择12行。
    

    绿色高亮处的代码在这里发挥了关键作用,它告诉oracle统计从第一条记录开始至最后一条记录的每月销售额。这个统计在记录集形成的过程中执行了12次,这时相当费时的!但至少我们解决了问题。


    unbounded preceding and unbouned following的意思针对当前所有记录的前一条、后一条记录,也就是表中的所有记录。那么假如我们直接指定从第一条记录开始直至末尾呢?看看下面的结果:

    SQL> select month,
      2         sum(tot_sales) month_sales,
      3         sum(sum(tot_sales)) over (order by month
      4            rows between 1 preceding and unbounded following) all_sales
      5    from orders
      6   group by month;
    
         MONTH MONTH_SALES  ALL_SALES
    ---------- ----------- ----------
             1      610697    6307766
             2      428676    6307766
             3      637031    5697069
             4      541146    5268393
             5      592935    4631362
             6      501485    4090216
             7      606914    3497281
             8      460520    2995796
             9      392898    2388882
            10      510117    1928362
            11      532889    1535464
            12      492458    1025347
    
    已选择12行。
    

    很明显这个语句错了。实际1在这里不是从第1条记录开始的意思,而是指当前记录的前一条记录。preceding前面的修饰符是告诉窗口函数执行时参考的记录数,如同unbounded就是告诉oracle不管当前记录是第几条,只要前面有多少条记录,都列入统计的范围。

    三、窗口函数进阶-滚动统计(累积/均值):

    考虑前面提到的第2个需求:列出每月的订单总额以及截至到当前月的订单总额。也就是说2月份的记录要显示当月的订单总额和1,2月份订单总额的和。3月份要显示当月的订单总额和1,2,3月份订单总额的和,依此类推。


    很明显这个需求需要在统计第N月的订单总额时,还要再统计这N个月来的订单总额之和。想想上面的语句,假如我们能够把and unbounded following换成代表当前月份的逻辑多好啊!很幸运的是Oracle考虑到了我们这个需求,为此我们只需要将语句稍微改成: curreent row就可以了。

    SQL> select month,
      2         sum(tot_sales) month_sales,
      3         sum(sum(tot_sales)) over(order by month
      4           rows between unbounded preceding and current row) current_total_sales
      5    from orders
      6   group by month;
    
         MONTH MONTH_SALES CURRENT_TOTAL_SALES
    ---------- ----------- -------------------
             1      610697              610697
             2      428676             1039373
             3      637031             1676404
             4      541146             2217550
             5      592935             2810485
             6      501485             3311970
             7      606914             3918884
             8      460520             4379404
             9      392898             4772302
            10      510117             5282419
            11      532889             5815308
            12      492458             6307766
    
    已选择12行。
    

    现在我们能得到滚动的销售总额了!下面这个统计结果看起来更加完美,它展现了所有我们需要的数据:

    SQL> select month,
      2         sum(tot_sales) month_sales,
      3         sum(sum(tot_sales)) over(order by month
      4         rows between unbounded preceding and current row) current_total_sales,
      5         sum(sum(tot_sales)) over(order by month
      6         rows between unbounded preceding and unbounded following) total_sales
      7    from orders
      8   group by month;
    
         MONTH MONTH_SALES CURRENT_TOTAL_SALES TOTAL_SALES
    ---------- ----------- ------------------- -----------
             1      610697              610697     6307766
             2      428676             1039373     6307766
             3      637031             1676404     6307766
             4      541146             2217550     6307766
             5      592935             2810485     6307766
             6      501485             3311970     6307766
             7      606914             3918884     6307766
             8      460520             4379404     6307766
             9      392898             4772302     6307766
            10      510117             5282419     6307766
            11      532889             5815308     6307766
            12      492458             6307766     6307766
    
    已选择12行。
     
    

    在一些销售报表中我们会时常看到求平均值的需求,有时可能是针对全年的数据求平均值,有时会是针对截至到当前的所有数据求平均值。很简单,只需要将:
    sum(sum(tot_sales))换成avg(sum(tot_sales))即可。

    四、窗口函数进阶-根据时间范围统计:

    前面我们说过,窗口函数不单适用于指定记录集进行统计,而且也能适用于指定范围进行统计的情况,例如下面这个SQL语句就统计了当天销售额和五天内的评价销售额:

     select trunc(order_dt) day,
                 sum(sale_price) daily_sales,
                 avg(sum(sale_price)) over (order by trunc(order_dt)
                          range between interval '2' day preceding 
                                         and interval '2' day following) five_day_avg
       from cust_order
     where sale_price is not null 
         and order_dt between to_date('01-jul-2001','dd-mon-yyyy')
         and to_date('31-jul-2001','dd-mon-yyyy')
    

    为了对指定范围进行统计,Oracle使用关键字range、interval来指定一个范围。上面的例子告诉Oracle查找当前日期的前2天,后2天范围内的记录,并统计其销售平均值。

    五、窗口函数进阶-first_value/last_value:

    Oracle提供了2个额外的函数:first_value、last_value,用于在窗口记录集中查找第一条记录和最后一条记录。假设我们的报表需要显示当前月、上一个月、后一个月的销售情况,以及每3 个月的销售平均值,这两个函数就可以派上用场了。
    select month,
                 first_value(sum(tot_sales)) over (order by month 
                                        rows between 1 preceding and 1 following) prev_month,
     
                 sum(tot_sales) monthly_sales,
     
                 last_value(sum(tot_sales)) over (order by month 
                                      rows between 1 preceding and 1 following) next_month,
     
                 avg(sum(tot_sales)) over (order by month 
                                     rows between 1 preceding and 1 following) rolling_avg
        from orders
     where year = 2001 
          and region_id = 6
      group by month
     order by month;
    

    首先我们来看:rows between 1 preceding and 1 following告诉Oracle在当前记录的前一条、后一条范围内查找并统计,而first_value和last_value在这3条记录中至分别找出第一条、第三条记录,这样我们就轻松地得到相邻三个月的销售记录及平均值了!

    六、窗口函数进阶-比较相邻记录:

    通过第五部分的学习,我们知道了如何利用窗口函数来显示相邻的记录,现在假如我们想每次显示当月的销售额和上个月的销售额,应该怎么做呢?

    从第五部分的介绍我们可以知道,利用first_value(sum(tot_sales) over (order by month rows between 1 preceding and 0 following))就可以做到了,其实Oracle还有一个更简单的方式让我们来比较2条记录,它就是lag函数。 leg函数类似于preceding和following 子句,它能够通过和当前记录的相对位置而被应用,在比较同一个相邻的记录集内两条相邻记录的时候特别有用。
    select  month,            
              sum(tot_sales) monthly_sales,
              lag(sum(tot_sales), 1) over (order by month) prev_month_sales
       from orders
     where year = 2001
          and region_id = 6
      group by month
     order by month;
    

    lag(sum(tot_sales),1)中的1表示以1月为基准。

    展开全文
  • 一、rows between 与 range between 用法 1. 相关关键词解析 unbounded 无边界 preceding 往前 following 往后 unbounded preceding 往前所有行,即初始行 n preceding 往前n行 unbounded following 往后所有行...

    一、rows between 与 range between 用法

    1. 相关关键词解析

    unbounded 无边界
    preceding 往前
    following 往后
    unbounded preceding 往前所有行,即初始行
    n preceding 往前n行
    unbounded following 往后所有行,即末尾行
    n following 往后n行
    current row 当前行
    
    语法
    (ROWS | RANGE) BETWEEN (UNBOUNDED | [num]) PRECEDING AND ([num] PRECEDING | CURRENT ROW | (UNBOUNDED | [num]) FOLLOWING)
    (ROWS | RANGE) BETWEEN CURRENT ROW AND (CURRENT ROW | (UNBOUNDED | [num]) FOLLOWING)
    (ROWS | RANGE) BETWEEN [num] FOLLOWING AND (UNBOUNDED | [num]) FOLLOWING

    2. rows between ... and ...

    rows:指以行号来决定frame的范围,是物理意义上的行。

    比如rows between 1 preceding and 1 following代表从当前行往前一行以及往后一行。

    3. range between ... and ...

    range:指以当前行在开窗函数中的值为根基,然后按照order by进行排序,最后根据range去加减上下界。是逻辑意义上的行。

    比如sum(score) over (PARTITION by id order by score ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) 表示按照id分组,按照score升序排序,然后以当前行的score,下界减一,上界加一,作为范围,将这范围里的score进行加总。

    讲的比较拗口,下面看个例子就懂了。

    二、举例

    1. 数据准备

    假设有表datadev.t_student,数据如下

    idscore
    stu_11
    stu_12
    stu_13
    stu_14
    stu_15
    stu_15

    2. 测试 rows between ... and ...

    SELECT id, score,
    sum(score) over (PARTITION by id) as a1,
    sum(score) over (PARTITION by id order by score) as a2,
    sum(score) over (PARTITION by id order by score ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as a3,
    sum(score) over (PARTITION by id order by score ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) as a4,
    sum(score) over (PARTITION by id order by 1) as a5
    from datadev.t_student;

    测试结果如下:

    分析:

    1. sum(score) over (PARTITION by id) as a1:按照id分组直接加总score,这种大家最熟悉了
    2. sum(score) over (PARTITION by id order by score) as a2:按照score排序,从起始行到当前行进行加总,与a3中的ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW不同的是,当score相同时,算相同排名,会一起加总。类似rank的概念。
    3. sum(score) over (PARTITION by id order by score ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW):从起始行到当前行进行加总,与a2不同的是,当score相同时,排名不同,不会加总到当前行。类似row_number的概念。
    4. sum(score) over (PARTITION by id order by score ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING):从起始行到末尾行进行加总,与a1相同。
    5. sum(score) over (PARTITION by id order by 1):作用与a2一样,这里order by 1,相当于score相同,因此全部加总。

    a1与a2在官网上的解释如下:

    • When ORDER BY is specified with missing WINDOW clause, the WINDOW specification defaults to RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.
    • When both ORDER BY and WINDOW clauses are missing, the WINDOW specification defaults to ROW BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING.

    因此,a1与a2等价于

    SELECT id, score,
    sum(score) over (PARTITION by id) as a1,
    sum(score) over (PARTITION by id ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) as a1,
    sum(score) over (PARTITION by id order by score) as a2,
    sum(score) over (PARTITION by id order by score RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as a2,
    from datadev.t_student;
    

     官网地址如下:

    LanguageManual WindowingAndAnalytics - Apache Hive - Apache Software Foundation

    3. 测试 range between ... and ...

    SELECT id, score,
    sum(score) over (PARTITION by id order by score RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) as b1,
    sum(score) over (PARTITION by id order by score RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING) as b2
    from datadev.t_student;

    测试结果如下:

     分析:

    1. sum(score) over (PARTITION by id order by score RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING):RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING 是默认值,可不写。
    2. sum(score) over (PARTITION by id order by score RANGE BETWEEN 1 PRECEDING AND UNBOUNDED FOLLOWING):按照id分组,score升序排序,并将当前行的score下界减一,上界为全部(可认为是无穷大),作为筛选范围。最后将符合筛选范围的score进行相加。

    b2运算过程分析如下:

    idscore运算过程运算b2
    stu_11[当前行的score值 - 1,∞] ==> 即[0, ∞]1+2+3+4+5+5=2020
    stu_12[当前行的score值 - 1,∞] ==> 即[1, ∞]1+2+3+4+5+5=2020
    stu_13[当前行的score值 - 1,∞] ==> 即[2, ∞]2+3+4+5+5=1919
    stu_14[当前行的score值 - 1,∞] ==> 即[3, ∞]3+4+5+5=1717
    stu_15[当前行的score值 - 1,∞] ==> 即[4, ∞]4+5+5=1414
    stu_15[当前行的score值 - 1,∞] ==> 即[4, ∞]4+5+5=1414

    4. 对比 range between ... and ... 与 rows between ... and ...

    SELECT id, score,
    sum(score) over (PARTITION by id order by score RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) as a,
    sum(score) over (PARTITION by id order by score ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING) as b
    from datadev.t_student;

    测试结果如下:

     分析:

    idscorerange运算过程range运算a(range)rows运算过程rows运算b(rows)
    stu_11[当前行的score值 - 1,当前行的score值 + 1] ==> 即[0, 2]1+2=33将当前行的上一行以及下一行
    的score进行相加
    1+2=33
    stu_12[当前行的score值 - 1,当前行的score值 + 1] ==> 即[1, 3]1+2+3=66将当前行的上一行以及下一行
    的score进行相加
    1+2+3=66
    stu_13[当前行的score值 - 1,当前行的score值 + 1] ==> 即[2, 4]2+3+4=99将当前行的上一行以及下一行
    的score进行相加
    2+3+4=99
    stu_14[当前行的score值 - 1,当前行的score值 + 1] ==> 即[3, 5]3+4+5+5=1717将当前行的上一行以及下一行
    的score进行相加
    3+4+5=1212
    stu_15[当前行的score值 - 1,当前行的score值 + 1] ==> 即[4, 6]4+5+5=1414将当前行的上一行以及下一行
    的score进行相加
    4+5+5=1414
    stu_15[当前行的score值 - 1,当前行的score值 + 1] ==> 即[4, 6]4+5+5=1414将当前行的上一行以及下一行
    的score进行相加
    5+5=1010

    参考文档:Hive 窗口与分析型函数

    展开全文
  • MySQL 中的 FOUND_ROWS() 函数

    千次阅读 2021-03-04 00:12:16
    移植IF @@ROWCOUNT <...1. found_rows() 函数的文档:1) found_rows() 的第一种使用情况( 带有 SQL_CALC_FOUND_ROWS,也带有limit ):A SELECT statement may include a LIMIT clause to restrict the...
  • mysql_affected_rows函数定义与用法汇总

    千次阅读 2021-01-18 21:51:58
    本篇文章收集了关于10有关mysql_affected_rows()函数的文章,推荐给大家1. php面试题之五——MySQL数据库(基础部分) mysql数据库下载64位 sql数据库实例下载 sql数据库补丁下载简介:Mysql数据库:php面试题之五——...
  • 1、介绍对于statement格式的binlog,所有增删改的SQL语句都记录在QUERY_EVENT...ROWS_EVENT分为3种:WRITE_ROWS_EVENT、UPDATE_ROWS_EVENT、DELETE_ROWS_EVENT,分别对应insert、update、delete。WRITE_ROWS_EVENT包...
  • openpyxl读取所有行数据之rows属性

    千次阅读 2021-01-14 00:55:08
    openpyxl读取一个sheet的所有行数据可以用rows属性,官方文档如下:If you need to iterate through all the rows or columns of a file, you can instead use the Worksheet.rows property:sheet的rows属性返回的是...
  • hive中控制窗口范围rows between的使用

    千次阅读 2021-01-20 14:56:41
    1.rows between的作用 在使用hsql完成一些业务需求的时候,我们经常会用到窗口函数,某些场景 下会涉及到需要控制窗口函数的范围来满足业务需求,这个时候就需要用到rows between了,使用rows between可以根据自己的...
  • SQL_CALC_FOUND_ROWS的用法

    千次阅读 2021-07-26 16:15:18
    我们在分页程序中往往这样写 SELECT COUNT(*) from `table` WHERE xxxxxx; // 查出符合条件的...SELECT SQL_CALC_FOUND_ROWS * FROM `table` WHERE xxxxxx limit M, N; // 获取指定页的数据,且统计总条数 其中的
  • mysql_num_rows() 函数

    千次阅读 2021-01-27 17:22:32
    Definition and Usage定义和用法The mysql_num_rows() function returns the number of rows in a recordset.mysql_num_rows()函数的作用是:取得结果集中行的数目。This function returns FALSE on failure.如果...
  • 分页:offset xxx rows fetch next xxx rows only 方式 分页实现的方法又多了一种,在SQL Server 2012版本中,TSQL在Order By子句中新增 Offset-Fetch子句,用于从有序的结果集中,跳过一定数量的数据行,获取指定...
  • 由于datav官方没有给出轮播表updateRows方法的具体使用案例,折磨了很久查到一位大佬分享的代码,经过尝试已经成功解决轮播表数据更新的问题,updateRows具体使用方法如下: 我这里是通过websocket接收后台发来的...
  • 使用PHP mysqli_num_rows函数方法

    千次阅读 2021-01-28 12:24:54
    使用PHP mysqli_num_rows函数方法发布时间:2020-05-21 16:20:46来源:51CTO阅读:220作者:三月下面一起来了解下使用PHP mysqli_num_rows函数方法,相信大家看完肯定会受益匪浅,文字在精不在多,希望使用...
  • doris报错:too many filtered rows

    千次阅读 2022-04-12 13:36:53
    { "TxnId": 831311, "Label": "testdoris201", "Status": "Fail", "Message": "too many filtered rows", "NumberTotalRows": 1, "NumberLoadedRows": 0, "NumberFilteredRows": 1, "NumberUnselectedRows": 0, ...
  • sheet.nrows有一个错误的值 – python excel文件我有一个很奇怪的问题 我试图从Excel文件中读取一些数据,但属性nrows有一个错误的值。 尽pipe我的文件有很多行,但它只返回2。我在pydev eclipse工作。 我不知道究竟...
  • 窗口函数rows between 、range between的使用

    千次阅读 多人点赞 2021-03-23 09:09:30
    1 rows between rows between 控制窗口函数的范围 使用rows between可以根据自己的需求任意的控制窗口函数的范围 UNBOUNDED :不受控的,无限的; PRECEDING : 在…之前; FOLLOWING: 在…之后; rows ...
  • 使用deleteRows 和 insertRows 动画 if #available(iOS 11.0, *) { self.tableView?.performBatchUpdates({ self.tableView?.deleteRows(at: [indexpath], with: UITableView.RowAnimation.fade) }, completion:...
  • 最近在一个项目中DBA同学问了一个问题:为什么很多慢查询日志中显示 Rows_examined : 0?需要说明的是, 这类慢查询语句都是类似 select count(*) from (…)t;在说明这个问题之前,我们先指出两个相关背景:1、MySQL的...
  • Explain字段解释——rows

    千次阅读 2020-12-15 10:33:35
    摘要:本文主要介绍Explain的常见字段——rows Explain字段解释——rows 这是一个很典型的优化,and后的字段加个索引之后,表t2使用的就是普通索引了,所以它的type就变成了ref,rows也表少了许多。 ...
  • unbounded preceding 起始行 unbounded following 结尾行 current row 当前行 1 preceding 当前行的前1行 ...select a.*,sum(mainid)over(rows between current row and unbounded following) as sums from ( select r
  • table[0].Rows.count问题

    2022-05-02 01:00:39
    asp.net中这个问题是经常,链接数据库出现的问题 其中table[0]表示查询的第一张表,Rows表示行如rows[0]表示第一行,count则表示他们的数量。
  • 今天本想用select * from user_tables t where t.NUM_ROWS>0查询表中数据大于0的表,可结果竟然没有查出来,网上搜了一下,原来NUM_ROWS这个字段有不少问题,除了不太准确外,还有个问题就是它不是即时查询的...
  • 1.rows between的作用 在使用hsql完成一些业务需求的时候,我们经常会用到窗口函数,某些场景 下会涉及到需要控制窗口函数的范围来满足业务需求,这个时候就需要用到rows between了,使用rows between可以根据自己的...
  • Removed k rows containing missing values

    千次阅读 2021-11-05 15:20:06
    Removed k rows containing missing values 目录 Removed k rows containing missing values 问题: 解决:coord_cartesian #所有的点都在范围内 #如果使用jitter有可能超出范围也会发生类似错误 问题: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,071,892
精华内容 428,756
关键字:

rows