greenplum-执行SQL创建Slice&Gang 学习计划。

最新推荐文章于 2024-01-02 11:04:06 发布
最新推荐文章于 2024-01-02 11:04:06 发布
阅读量1.3k 收藏 2
点赞数 2
分类专栏： greenplum 数据库源码分析 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dusx1981/article/details/113575413
版权

相关概念：

  • **Motion：**除了常见的数据库操作（例如表扫描，联接等）之外，Greenplum数据库还有一种名为motion的算子。motion用于在segment之间移动元组。
  • **Slice：**为了在查询执行期间实现最大的并行度，Greenplum将查询计划的工作划分为slices。slice是计划中可以独立进行处理的部分。查询计划会为motion生成slice，motion的每一侧都有一个slice。
  • **Gang：**属于同一个slice但是运行在不同的segment上的进程，称为gang。

实验环境：

  • greenplum版本：6，
  • 集群环境：单master，没有standerby Master. 两个 primary segment，没有mirror。

实验日志：

test=# select * from test;
DEBUG1:  00000: Message type Q received by from libpq, len = 20
DEBUG3:  00000: StartTransactionCommand
DEBUG3:  00000: StartTransaction

LOG:  00000: statement: select * from test;
LOCATION:  exec_simple_query, postgres.c:1639
[OPT]: Using default search strategy

 Gather Motion 2:1  (slice1; segments: 2)  (cost=0.00..431.00 rows=1 width=8)
   ->  Seq Scan on test  (cost=0.00..431.00 rows=1 width=8)

DEBUG1:  00000: GPORCA produced plan
LOG:  00000: plan:
DETAIL:     {PLANNEDSTMT 
   :commandType 1 
   :planTree 
      {MOTION 
      :motionID 1 
      :motionType 1 
      :nMotionNodes 1 
      :nInitPlans 0 
      :lefttree 
         {SEQSCAN 
         :flow 
            {FLOW 
            :flotype 0 
            }
         :nMotionNodes 0 
         :nInitPlans 0 
         }
      }
   :rtable (
      {RTE 
      :eref 
         {ALIAS 
         :aliasname test 
         :colnames ("id" "age")
         }
      }
   )
   :utilityStmt <> 
   :subplans <> 
   }

Slice 1 on seg0
DEBUG1:  00000: Message type M received by from libpq, len = 457  (seg0 slice1 192.168.106.132:7000 pid=43071)
DEBUG3:  00000: StartTransactionCommand  (seg0 slice1 192.168.106.132:7000 pid=43071)
DEBUG3:  00000: StartTransaction  (seg0 slice1 192.168.106.132:7000 pid=43071)
DEBUG3:  00000: CommitTransactionCommand  (seg0 slice1 192.168.106.132:7000 pid=43071)
DEBUG3:  00000: CommitTransaction  (seg0 slice1 192.168.106.132:7000 pid=43071)

Slice 1 on seg1
DEBUG1:  00000: Message type M received by from libpq, len = 457  (seg1 slice1 192.168.106.133:7000 pid=43218)
DEBUG3:  00000: StartTransactionCommand  (seg1 slice1 192.168.106.133:7000 pid=43218)
DEBUG3:  00000: StartTransaction  (seg1 slice1 192.168.106.133:7000 pid=43218)
DEBUG3:  00000: CommitTransactionCommand  (seg1 slice1 192.168.106.133:7000 pid=43218)
DEBUG3:  00000: CommitTransaction  (seg1 slice1 192.168.106.133:7000 pid=43218)

master
DEBUG3:  00000: CommitTransactionCommand
DEBUG3:  00000: CommitTransaction

上面的日志，是经过整理的，去掉了一些无用的或这里不关心的信息。

上面是执行语句select * from test;的调试信息，从上面可以看到：

  • (1)执行计划：

     Gather Motion 2:1  (slice1; segments: 2)  (cost=0.00..431.00 rows=1 width=8)
		->  Seq Scan on test  (cost=0.00..431.00 rows=1 width=8)

  • (2)执行计划树：

     从日志可以看到，执行计划日志和执行计划树的对应关系：Gather Motion-->MOTION，Seq Scan-->SEQSCAN。

  • (3)Slice0：根slice，在master上跑。

     GangType::GANGTYPE_UNALLOCATED,       /* a root slice executed by the qDisp */，slice根节点（master）上的slice类型。

  • (4)Slice1：在seg1,seg2上跑，具体见上面日志。

     Gather Motion 2:1  (slice1; segments: 2)  (cost=0.00..431.00 rows=1 width=8)

代码分析：

void
PostgresMain(int argc, char *argv[], const char *dbname, const char *username)
{
	......
    for (;;)
    {
 		......
        switch (firstchar)
        {
            case 'Q':           /* simple query */
                {
                    ......
                    else
                        exec_simple_query(query_string);
                    send_ready_for_query = true;
                }
                break;
         }
     }
}


日志截取：
DEBUG1:  00000: Message type Q received by from libpq, len = 20
......
LOCATION:  exec_simple_query, postgres.c:1639
  • 从日志和逻辑可以看到，master执行SQL的入口点就在这里，当第一个字符是‘Q’时，表示要执行语句。而执行SQL字符串的入口函数，就是exec_simple_query。
  • 这里先忽略SQL的解析，计划制定，直接到初始化slice，和后面的步骤，这里重点讨论并行计划中的slice和gang。

Slice相关结构：

 * Slice 0 is the root slice of plan as a whole.
 * Slices 1 through nMotion are motion slices with a sending motion at
 *  the root of the slice.
 * Slices nMotion+1 and on are root slices of initPlans.
typedef struct SliceTable
{
    NodeTag     type;

    int         nMotions;       /* The number Motion nodes in the entire plan */
    int         nInitPlans;     /* The number of initplan slices allocated */
    int         localSlice;     /* Index of the slice to execute. */
    List       *slices;         /* List of slices */
    int         instrument_options; /* OR of InstrumentOption flags */
    uint32      ic_instance_id;
} SliceTable;

由注释可以看到，Slice分为三类：

  • 根slice，在master上，id为0

  • Motion的slice

  • initPlans的slice

Segment信息表：

template1=# select * from gp_segment_configuration;
 dbid | content | role | preferred_role | mode | status | port | hostname | address |        datadir        
------+---------+------+----------------+------+--------+------+----------+---------+-----------------------
    1 |      -1 | p    | p              | n    | u      | 5432 | mdw      | mdw     | /data/master/gpseg-1
    2 |       0 | p    | p              | n    | u      | 7000 | sdw1     | sdw1    | /data1/primary/gpseg0
    3 |       1 | p    | p              | n    | u      | 7000 | sdw2     | sdw2    | /data1/primary/gpseg1
(3 rows)

由这张表可以看到，master的信息中content为-1，这也与代码中的gp_segment_config.h中的MASTER_CONTENT_ID相对应，实际上，Master的节点，会做GpIdentity.segindex = MASTER_CONTENT_ID的初始化，所以，只要segindex是-1，我们可以认为当前在master节点上。

Slice创建调用栈：
在这里插入图片描述

void
InitSliceTable(EState *estate, int nMotions, int nSubplans)
{
    SliceTable *table;
    Slice      *slice;
    int         i,
                n;
    MemoryContext oldcontext;
    n = 1 + nMotions + nSubplans;
  
    table = makeNode(SliceTable);
    table->nMotions = nMotions;
	table->nInitPlans = nSubplans;
	......
    for (i = 0; i < n; i++)
    {
        slice = makeNode(Slice);
        slice->sliceIndex = i;
         ......
        slice->gangType = GANGTYPE_UNALLOCATED;
        ......
        table->slices = lappend(table->slices, slice);
    }
	estate->es_sliceTable = table;
	......
}

由日志可以看到：

:nMotionNodes 1 
:nInitPlans 0 

所以，InitSliceTable创建了两个slice，index分别为0，1，实际上，对应这slice0和slice1。

PlanStmt相关Log信息：

DETAIL:     {PLANNEDSTMT 
   ......
   :intoClause <> 
   :copyIntoClause <> 
   :refreshClause <> 
   ......
}

Slice初始化调用栈：
在这里插入图片描述

static void
FillSliceTable(EState *estate, PlannedStmt *stmt)
{
    FillSliceTable_cxt cxt;
    SliceTable *sliceTable = estate->es_sliceTable;

    if (!sliceTable)
        return;
    cxt.prefix.node = (Node *) stmt;
    cxt.estate = estate;
    cxt.currentSliceId = 0;
    if (stmt->intoClause != NULL || stmt->copyIntoClause != NULL || stmt->refreshClause)
	{
    	......
    }
    /*
     * NOTE: We depend on plan_tree_walker() to recurse into subplans of
     * SubPlan nodes.
     */
    FillSliceTable_walker((Node *) stmt->planTree, &cxt);
}

通过上面的日志信息可以看到：if (stmt->intoClause != NULL || stmt->copyIntoClause != NULL || stmt->refreshClause) 这个条件不满足，我们重点看下面的函数

/* ----------------
typedef struct ModifyTable
{
    ......
CmdType     operation;      /* INSERT, UPDATE, or DELETE */
......
} ModifyTable;
由注释可以看到，这个结构体，代表修改表的操作。

static bool FillSliceTable_walker(Node *node, void *context)
{
    if (IsA(node, ModifyTable))
	{
    	......
    }
    /* A DML node is the same as a ModifyTable node, in ORCA plans. */
    if (IsA(node, DML))
    {
 	     ......
    }
    if (IsA(node, Motion))
	{
    	......
        /* Top node of subplan should have a Flow node. */
        Insist(motion->plan.lefttree && motion->plan.lefttree->flow);
        sendFlow = motion->plan.lefttree->flow;
        /* Look up the sending gang's slice table entry. */
        sendSlice = (Slice *) list_nth(sliceTable->slices, motion->motionID);
        /* Look up the receiving (parent) gang's slice table entry. */
        recvSlice = (Slice *)list_nth(sliceTable->slices, parentSliceIndex);
        /* Sending slice become a children of recv slice */
        recvSlice->children = lappend_int(recvSlice->children, sendSlice->sliceIndex);
        sendSlice->parentIndex = parentSliceIndex;
        sendSlice->rootIndex = recvSlice->rootIndex;
        /* The gang beneath a Motion will be a reader. */
        sendSlice->gangType = GANGTYPE_PRIMARY_READER;

        if (sendFlow->flotype != FLOW_SINGLETON) //日志信息（:flotype 0 ），FLOW_SINGLETON为1，所以走入这个分支。
        {
            sendSlice->gangType = GANGTYPE_PRIMARY_READER;
            /*
             * If the PLAN is generated by ORCA, We assume that they
             * distpatch on all segments.
             */
            if (stmt->planGen == PLANGEN_PLANNER)，日志信息（:planGen 1 ），PLANGEN_PLANNER为0，所以走下面的分支。
                FillSliceGangInfo(sendSlice, sendFlow->numsegments);
            else
                FillSliceGangInfo(sendSlice, getgpsegmentCount());
        }
        else
        {
             ......
        }
        ......
        /* recurse into children */
        cxt->currentSliceId = motion->motionID;
        result = plan_tree_walker(node, FillSliceTable_walker, cxt);
        cxt->currentSliceId = parentSliceIndex;
        return result;
    }
    if (IsA(node, SubPlan))
	{
      	......
    }
    return plan_tree_walker(node, FillSliceTable_walker, cxt);
}

逻辑相关结构体：

typedef enum FlowType
{
    FLOW_UNDEFINED,     /* used prior to calculation of type of derived flow */
    FLOW_SINGLETON,     /* flow has single stream */
    FLOW_REPLICATED,    /* flow is replicated across IOPs */
    FLOW_PARTITIONED,   /* flow is partitioned across IOPs */
} FlowType;

typedef enum PlanGenerator
{
    PLANGEN_PLANNER,            /* plan produced by the planner*/
    PLANGEN_OPTIMIZER,          /* plan produced by the optimizer*/
} PlanGenerator;

逻辑相关的日志信息：

DETAIL:     {PLANNEDSTMT 
   :commandType 1 
   :planGen 1 
   :planTree 
      {MOTION 
      :motionID 1 
      :nMotionNodes 1 
      :nInitPlans 0 
      :lefttree 
         {SEQSCAN......}
         :flow 
         {FLOW 
            :flotype 0 
            :req_move 0 
            :locustype 0 
            :segindex 0 
            :numsegments 1 
            :hashExprs <> 
            :hashOpfamilies <> 
            :flow_before_req_move <>
         }
      }
   :rtable (
      {RTE 
      :eref 
         {ALIAS 
         :aliasname test 
         :colnames ("id" "age")
         }
      }
   )
   :utilityStmt <> 
   :subplans <> 
   }

FillSliceTable_walker有四个分支：

  • if (IsA(node, ModifyTable))
  • if (IsA(node, DML))
  • if (IsA(node, Motion))
  • if (IsA(node, SubPlan))

FillSliceTable_walker调用逻辑：

FillSliceTable_walker((Node *) stmt->planTree, &cxt);
  • 可以看到，smpt对应着Log的PLANNEDSTMT
    关键字，而日志里面，planTree是一个Motion（MOTION）。

所以流程会走Motion对应的分支。

第三个分支：

  • FillSliceTable_walker被FillSliceTable调用，在FillSliceTable中cxt.currentSliceId= 0; 所以这里FillSliceTable_walker中，int parentSliceIndex = cxt->currentSliceId;，parentSliceIndex 为0。
  • 由日志可以看到，motion->motionID是1（:motionID 1）。所以sendSlice是日志里的slice1，recvSlice是slice0。

这个函数做了四件事：

  • 设置recvSlice为slice0，把slice1（sendSlice）设置为子slice0的子节点。
  • 设置slice1类型为GANGTYPE_PRIMARY_READER。
  • 设置把slice1发送到所有的segment。
  • 对slice1调用plan_tree_walker，待整理。

上下文变量初始化：

static int
BackendStartup(Port *port)
{

    pid = fork_process();
    if (pid == 0)               /* child */
	{
		......
        MyProcPid = getpid();   /* reset MyProcPid */
        ......
	}
}

由此可见，MyProcPID代表当前被fork的子进程。

创建Gang调用栈：
在这里插入图片描述
代码：

void
AssignGangs(CdbDispatcherState *ds, QueryDesc *queryDesc)
{
    ......
    InventorySliceTree(ds, sliceTable->slices, rootIdx);
}

这个函数调用InventorySliceTree实现功能。

void
InventorySliceTree(CdbDispatcherState *ds, List *slices, int sliceIndex)
{
    ListCell *cell;
    int childIndex;
    Slice *slice = list_nth(slices, sliceIndex);

    if (slice->gangType == GANGTYPE_UNALLOCATED)
    {
        slice->primaryGang = NULL;
        slice->primaryProcesses = getCdbProcessesForQD(true);
    }
    else
    {
        Assert(slice->segments != NIL);
        slice->primaryGang = AllocateGang(ds, slice->gangType, slice->segments);
        setupCdbProcessList(slice);
    }
    foreach(cell, slice->children)
    {
        childIndex = lfirst_int(cell);
        InventorySliceTree(ds, slices, childIndex);
    }
}
  • 由前面的分析可以知道，slice0的gangType为GANGTYPE_UNALLOCATED，所以，slice0的primaryProcesses被设置。而slice1走else的逻辑。最后，递归执行InventorySliceTree。我们的场景只有两个slice，所以不会进foreach的逻辑。

slice0的处理：

/*
 * getCdbProcessForQD:  Manufacture a CdbProcess representing the QD,
 * as if it were a worker from the executor factory.
 *
 * NOTE: Does not support multiple (mirrored) QDs.
 */
List *
getCdbProcessesForQD(int isPrimary)
{
    CdbComponentDatabaseInfo *qdinfo;
	CdbProcess *proc;

    Assert(Gp_role == GP_ROLE_DISPATCH);
    qdinfo = cdbcomponent_getComponentInfo(MASTER_CONTENT_ID);
    proc = makeNode(CdbProcess);

	......
	proc->pid = MyProcPid;
	......
    list = lappend(list, proc);
    return list;
}
  • 由上面的实现可以看到，primaryProcesses被设置为当前的进程。可以看到，这个函数，是为master分配slice的执行进程的，实际上就是当前的dispatch进程。（关于Gp_role的描述，可以看我的另一篇文章：greenplum-QD&QE启动流程）所以，slice0上没有被分配gang。

slice1的处理：

/*
 * Creates a new gang by logging on a session to each segDB involved.
 *
 * elog ERROR or return a non-NULL gang.
 */
Gang *
AllocateGang(CdbDispatcherState *ds, GangType type, List *segments)
{
    MemoryContext   oldContext;
    SegmentType     segmentType;
    Gang            *newGang = NULL;
	int             i;
	......
    if (Gp_role != GP_ROLE_DISPATCH)
    {
        elog(FATAL, "dispatch process called with role %d", Gp_role);
	}

    if (type == GANGTYPE_PRIMARY_WRITER)
        segmentType = SEGMENTTYPE_EXPLICT_WRITER;
    /* for extended query like cursor, must specify a reader */
    else if (ds->isExtendedQuery)
        segmentType = SEGMENTTYPE_EXPLICT_READER;
    else
        segmentType = SEGMENTTYPE_ANY;
    
	......
    newGang = cdbgang_createGang(segments, segmentType);
    newGang->allocated = true;
    newGang->type = type;
    /*
     * Push to the head of the allocated list, later in
     * cdbdisp_destroyDispatcherState() we should recycle them from the head to
     * restore the original order of the idle gangs.
     */
    ds->allocatedGangs = lcons(newGang, ds->allocatedGangs);
	ds->largestGangSize = Max(ds->largestGangSize, newGang->size);

    if (type == GANGTYPE_PRIMARY_WRITER)
    {
        /*
         * set "whoami" for utility statement. non-utility statement will
         * overwrite it in function getCdbProcessList.
         */
        for (i = 0; i < newGang->size; i++)
            cdbconn_setQEIdentifier(newGang->db_descriptors[i], -1);
    }
    return newGang;
}

由前面的逻辑知道，slice1的类型为GANGTYPE_PRIMARY_READER。这里，segmentType为SEGMENTTYPE_ANY。

创建libpq连接调用链：
在这里插入图片描述
代码：

Gang *
cdbgang_createGang_async(List *segments, SegmentType segmentType)
{
    Gang    *newGangDefinition;

    newGangDefinition = NULL;
	/* allocate and initialize a gang structure */
	......
    newGangDefinition = buildGangDefinition(segments, segmentType);
    CurrentGangCreating = newGangDefinition;
	totalSegs = getgpsegmentCount();
	size = list_length(segments);
	......
    PG_TRY();
    {
        for (i = 0; i < size; i++)
        {
             ......
            segdbDesc = newGangDefinition->db_descriptors[i];

            ret = build_gpqeid_param(gpqeid, sizeof(gpqeid),
                                     segdbDesc->isWriter,
                                     segdbDesc->identifier,
                                     segdbDesc->segment_database_info->hostSegs,
                                     totalSegs * 2);
             ......
            cdbconn_doConnectStart(segdbDesc, gpqeid, options);
  
            pollingStatus[i] = PGRES_POLLING_WRITING;
        }

        for (;;)
        {......}
 	 ......
     return newGangDefinition;
}

这里我们省略了网络连接，交互的细节，重点看Gang相关的东西：

  • buildGangDefinition，为每个Gang里面的segment，创建一个SegmentDatabaseDescriptor，可以理解为一个代表Segment Database的对象。
  • build_gpqeid_param，生成gpqeid，这会让segment初始化QE角色。
  • cdbconn_doConnectStart，用这个函数，连接每个SegmentDatabaseDescriptor代表的数据库，这里就是每个segment上的数据库，从前面的分析可以知道，当前的场景，是连接所有的segment。而每个连接，会对应生成一个QE的进程，QE的初始化流程，见：greenplum-QD&QE启动流程

由此，我们可以得到当前实验场景下的网络拓扑：
在这里插入图片描述
所以，可以把slice看成管理Gang的数据结构，而Gang是管理分布式进程工作的数据结构。

dusx1981
关注
专栏目录
Greenplum的架构和核心引擎
MyySophia的博客
02-19 215
目录 一、Greenplum的架构 1.1Greenplum Master 1.2Greenplum Segment 1.3Greenplum Interconnect 1.4Greenplum Standby Master 1.5Greenplum Mirror Segment 二、Greenplum查询计划 2.1 单机查询计划 2.1 并行查询计划 2.1.1Motion 2.2.2Slice和Gang 三、Greenplum数据库查询处理的过程 3.1...
Greenplum内存问题处理
JustinMars的博客
09-27 1618
错误 java.sql.SQLException: [Pivotal][Greenplum JDBC Driver][Greenplum]Out of memory (seg1 slice3 *.*.3.245:6001 pid=27558). 原因 内存不足错误消息表明Greenplum的Segment、主机和进程遇到了内存不足错误。 提示：Greenplum数据库集群中，内存管理对性能有显著的影响。默认设置适合于大部分环境。不要更改默认设置，除非理解系统上的内存特点和使用。 原因 解决方案
[转帖]Greenplum: 基于PostgreSQL的分布式数据库内核揭秘(下篇)
weixin_30265103的博客
09-19 557
Greenplum: 基于PostgreSQL的分布式数据库内核揭秘(下篇) http://www.postgres.cn/v2/news/viewone/1/454 原作者：姚延栋　创作时间：2019-05-08 17:25:25+08 采编：wangliyun 发布时间：2019-05-09 08:25:28 欢迎大家踊跃投稿，投稿信箱：pres...
Go速成无压力【七】：切片 （Slices）
数据库爆破专家的博客
06-14 522
文章目录（一）切片 (Slices)（二）切片就像对数组的引用（三）切片的文法（四）切片的默认值 （一）切片 (Slices) 一个数组有足够的适合的长度，但是切片是从另一个方面来定义，是一个动态的尺寸，相当于一个灵活可扩展的数组；在实际操作练习中，切片比数组更常用 (1) 切片的类型表示用 [ ]T ，比如[ ] int ， 则切片的类型为int型； (2) 一个切片由指定的两个索引组成，一个低边界的索引和一个高边界的索引，使用分号分割开，写法如：a[low:high]; (3) 切片索引选
greenplum sql执行过程
z072192的博客
12-28 270
greenplum sql执行过程
Greenplum介绍
weixin_33859231的博客
04-01 249
本文介绍了Greenplum的一些内部架构。 GP的官方文档请参见：http://gpdb.docs.pivotal.io/4380/admin_guide/intro/arch_overview.html ； 阿里云GP的产品介绍参见：https://help.aliyun.com/document_detail/35387.html 由于后面讨论的所...
slices
weixin_44718747的博客
11-27 819
1、slices的数据结构 slice的底层确实引用一个数组对象。一个slice由三个部分构成：指针、长度和容量。 指针指向第一个slice元素对应的底层数组元素的地址， 长度对应slice中元素的数目；长度不能超过容量， 容量一般是从slice的开始位置到底层数据的结尾位置。内置的len和cap函数分别返回slice的长度和容量。 多个slice之间可以共享底层的数据，并且引用的数组部分区间可能重叠 其他任何对slices所做的操作最终都会反馈到它的底层数组上,因为slice值包含指向第一个slice元
slice()
qq_26239917的博客
03-22 2594
slice() stringObject.slice(start,end) slice()方法与substring()方法非常类似，它传入的两个参数也分别对应着开始位置和结束位置。而区别在于，slice()中的参数可以为负值，如果参数是负数，则该参数规定的是从字符串的尾部开始算起的位置。也就是说，-1 指字符串的最后一个字符。 var str = ‘abcdefg’; console.log(st...
Greenplum问题定位及性能调优
Greenplum中文社区
07-16 1151
...
PostgreSQL GreenPlum HAWQ三者的关系及演变过程
热门推荐
YYDU_666的博客
06-27 1万+
这个日程安排同时也是我们公司核心团队的技术进阶史。公司创始团队成员有幸以核心开发者的角色参与，从单机版的关系型数据库（PostgreSQL），大规模并行处理（MPP）数据库（Greenplum Database）到SQL on Hadoop解决方案（Apache HAWQ），以及最新的SQL on Cloud数据仓库（HashData）。通过回顾这个技术演进的历程，我们将阐述如何一步一步地解决联机...
Greenplum segment级问题的排查 - gp_session_role=utility (含csvlog日志格式解读)
weixin_34117211的博客
09-15 2049
标签 PostgreSQL , Greenplum , segment , utility 背景 有些时候，我们在使用Greenplum时，你会发现明明连接数是够的，但是报错的时候segment连接满无法正确连接，因为对外的接口都是MASTER，如果发现这里问题如何排查？ 00000 LOG: Failed connection to seg...
SQLalchemy之limit、offset、slice
why404
01-27 4127
limit、offset、slice使用 limit：可以限制查询的时候只查询前几条数据。 属top-N查询 articles = session.query(Article).limit(10).all() offset：可以限制查找数据的时候过滤掉前面多少条。可指定开始查询时的偏移量。 articles = session.query(Article).offset(10).l...
14 Greenplum 常用设置参数
知识的力量
01-25 5031
14 Greenplum 常用设置参数 14.1 查看服务器的参数列表 $ psql -c 'SHOW ALL;'   详细的参数请查看:https://blog.csdn.net/xfg0218/article/details/86648761   14.1.1 运行时统计信息收集参数 这些参数控制服务器统计数据收集功能。如果启用了统计信息收集,您可以访问使用pg_stat和系统目...
Planning ADSO--2 Data Slices和Characteristic Relations/如何在HANA数据库上实现
weixin_45689053的博客
11-17 235
Planning ADSO
greenplum Explicit Redistribute Motion 代码
01-26 328
Explicit Redistribute Motion The Explicit Redistribute iterator moves tuples to segments explicitly specified in the segment ID column of the tuples. This is differs from a Redistribute Motion i...
GreenPlum-数据世界的绿洲
最新发布
dafsq的博客
01-02 1770
GreenPlum-数据世界的绿洲
Greenplum , HAWQ outer join与motion问题讲解
weixin_34148508的博客
09-09 186
Greenplum , HAWQ outer join与motion问题讲解 作者 digoal 日期 2016-09-05 标签 PostgreSQL , HAWQ , Greenplum , OUTER JOIN , Motion 背景 Greenplum，HAWQ是分布式的数据库，在建表时，我们可以选择分布列，或者选择随机分布。 多个表做...
sqlalchemy limmit、offset及slice操作详解
weixin_42989364的博客
03-24 1151
一、limit 　　 我们知道 session.query(Arctire).all() 可以查询表中所有数据。如果想要查询表中前十条数据，怎么办呢？这时候，我们就可以使用limit了，当然你也可以其它方法。 　　 语法： 　　 results = session.query(Arctire).limit(10).all() 　　 print(results) ------------------...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值