PostgreSQL技术内幕17：PG分区表

文章目录

    • 0.简介
    • 1.概念介绍
    • 2.分区表技术产生的背景
    • 3.分区类型及使用方式
    • 4.实现原理
      • 4.1 分区表创建
      • 4.2 分区表查询
      • 4.3 分区表写入
      • 4.4 分区表删除

0.简介

本文主要介绍PG中分区表的概念，产生分区表技术的原因，使用方式和其内部实现原理，旨在能对PG分区表技术有一个系统的说明。

1.概念介绍

分区表是数据库用于管理大量数据的一种技术，它允许将一个大表分割成多个小表，这些小表在物理上是独立的，但在逻辑上作为一个整体被查询和更新。分区表的主要优势在于提高查询性能，特别是当查询集中在少数几个分区时。此外，分区表还可以简化数据的批量删除和加载，以及将不常用的数据迁移到成本较低的存储介质上实现冷热分离。

在这里插入图片描述
1）主表/父表/Master Table：该表是创建子表的模板。它是一个正常的普通表，但正常情况下它并不储存任何数据。
2）子表/分区表/Child Table/Partition Table：这些表继承并属于一个主表。子表中存储所有的数据。主表与分区表属于一对多的关系，也就是说，一个主表包含多个分区表，而一个分区表只从属于一个主表

2.分区表技术产生的背景

在使用数据库过程中，随着时间的推移，每张表数据量会不断增加，造成查询速度越来越慢，在分区表之前有很多查询的技术去优化它，比如添加特殊的索引，将磁盘分区（把日志文件放到单独的磁盘分区），调整参数等等。这些优化技术都能对查询性能做出或多或少的提升，但其并没有对于表特点以及局部性的原理进行合理应用，因为对于很多应用来说，许多历史数据对于查询可能并没有太多用处，或者是某一列是特定值时是更为关系的数据，如果能够将不常用数据进行隐藏，就能大大提高查询速度，分区表就是为了解决这个问题而产生的。比如可以按照时间作为分区键进行分区将新老数据分离。

3.分区类型及使用方式

PG 10以后支持三种分区，以下都使用主流的使用方式声明式分区（还有表继承）进行说明：
1）范围（Range）分区

CREATE TABLE students (grade INTEGER) PARTITION BY RANGE(grade);
CREATE TABLE stu_fail PARTITION OF students FOR VALUES FROM (MINVALUE) TO (60);
CREATE TABLE stu_pass PARTITION OF students FOR VALUES FROM (60) TO (MAXVALUE);
 \d+  students
                                 Table "public.students"
 Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description
--------+---------+-----------+----------+---------+---------+--------------+-------------
 grade  | integer |           |          |         | plain   |              |
Partition key: RANGE (grade)
Partitions: stu_fail FOR VALUES FROM (MINVALUE) TO (60),
            stu_pass FOR VALUES FROM (60) TO (MAXVALUE)

\d+ stu_fail
                                 Table "public.stu_fail"
 Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description
--------+---------+-----------+----------+---------+---------+--------------+-------------
 grade  | integer |           |          |         | plain   |              |
Partition of: students FOR VALUES FROM (MINVALUE) TO (60)
Partition constraint: ((grade IS NOT NULL) AND (grade < 60))

可以看出，其中最大值是小于关系，不是小于等于关系。

2）列表（List）分区
列表分区明确指定根据某字段的某个具体值进行分区，默认分区（可选值）保存不属于任何指定分区的列表值。

CREATE TABLE students (status character varying(30)) PARTITION BY LIST(status);
CREATE TABLE stu_active PARTITION OF students FOR VALUES IN ('ACTIVE');
CREATE TABLE stu_exp PARTITION OF students FOR VALUES IN ('EXPIRED');
CREATE TABLE stu_others PARTITION OF students DEFAULT;

\d+  students
                                         Table "public.students"
 Column |         Type          | Collation | Nullable | Default | Storage  | Stats target | Description
--------+-----------------------+-----------+----------+---------+----------+--------------+-------------
 status | character varying(30) |           |          |         | extended |              |
Partition key: LIST (status)
Partitions: stu_active FOR VALUES IN ('ACTIVE'),
            stu_exp FOR VALUES IN ('EXPIRED'),
            stu_others DEFAULT

\d+  stu_others;
                                        Table "public.stu_others"
 Column |         Type          | Collation | Nullable | Default | Storage  | Stats target | Description
--------+-----------------------+-----------+----------+---------+----------+--------------+-------------
 status | character varying(30) |           |          |         | extended |              |
Partition of: students DEFAULT
Partition constraint: (NOT ((status IS NOT NULL) AND ((status)::text = ANY (ARRAY['ACTIVE'::character varying(30), 'EXPIRED'::character varying(30)]))))

3）哈希（Hash）分区
通过对每个分区使用取模和余数来创建hash分区，modulus指定了对N取模，而remainder指定了除完后的余数。

CREATE TABLE students (id INTEGER) PARTITION BY HASH(id);
CREATE TABLE stu_part1 PARTITION OF students FOR VALUES WITH (modulus 3, remainder 0);
CREATE TABLE stu_part2 PARTITION OF students FOR VALUES WITH (modulus 3, remainder 1);
CREATE TABLE stu_part3 PARTITION OF students FOR VALUES WITH (modulus 3, remainder 2);

\d+ students;
                                 Table "public.students"
 Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description
--------+---------+-----------+----------+---------+---------+--------------+-------------
 id     | integer |           |          |         | plain   |              |
Partition key: HASH (id)
Partitions: stu_part1 FOR VALUES WITH (modulus 3, remainder 0),
            stu_part2 FOR VALUES WITH (modulus 3, remainder 1),
            stu_part3 FOR VALUES WITH (modulus 3, remainder 2)

\d+ stu_part1;
                                 Table "public.stu_part1"
 Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description
--------+---------+-----------+----------+---------+---------+--------------+-------------
 id     | integer |           |          |         | plain   |              |
Partition of: students FOR VALUES WITH (modulus 3, remainder 0)
Partition constraint: satisfies_hash_partition('16439'::oid, 3, 0, id)

PG分区还支持创建子分区：LIST-LIST，LIST-RANGE，LIST-HASH，RANGE-RANGE，RANGE-LIST，RANGE-HASH，HASH-HASH，HASH-LIST和HASH-RANGE；以及和普通表之间互相转换，DETACH PARTITION可以将分区表转换为普通表，而attach partition可以将普通表附加到分区表上。

4.实现原理

4.1 分区表创建

分区表创建相对简单，对PG来说实际是一张逻辑表对应多张物理表，下面简单看创建时其分区表相关的调用流程。

--> transformPartitionBound  
                    --> RelationGetPartitionKey
                    --> get_partition_strategy
                    --> transformPartitionBoundValue
                    --> transformPartitionRangeBounds
                        --> validateInfiniteBounds
                --> check_new_partition_bound
                --> StorePartitionBound // Update pg_class tuple of rel to store the partition bound and set relispartition to true
                --> StoreCatalogInheritance // 向系统表pg_inherits插入信息
                // 处理stmt->partspec
                --> transformPartitionSpec
                --> ComputePartitionAttrs
                --> StorePartitionKey // 向pg_partitioned_table中插入分区键等信息

4.2 分区表查询

分区表查询是要根据条件查询一定数量的子表然后进行返回，其主要分为三步：
1）识别分区表并找到所有的分区子表

/*
 * expand_inherited_tables
 *    Expand each rangetable entry that represents an inheritance set
 *    into an "append relation".  At the conclusion of this process,
 *    the "inh" flag is set in all and only those RTEs that are append
 *    relation parents.
 */
void
expand_inherited_tables(PlannerInfo *root)
{
  Index    nrtes;
  Index    rti;
  ListCell   *rl;

  /*
   * expand_inherited_rtentry may add RTEs to parse->rtable. The function is
   * expected to recursively handle any RTEs that it creates with inh=true.
   * So just scan as far as the original end of the rtable list.
   */
  nrtes = list_length(root->parse->rtable);
  rl = list_head(root->parse->rtable);
  for (rti = 1; rti <= nrtes; rti++)
  {
    RangeTblEntry *rte = (RangeTblEntry *) lfirst(rl);

    expand_inherited_rtentry(root, rte, rti);
    rl = lnext(rl);
  }
}

2）根据约束条件识别需要查询的分区,也就是分区裁剪，只读取需要的分区;

prune_append_rel_partitions
 *    Process rel's baserestrictinfo and make use of quals which can be
 *    evaluated during query planning in order to determine the minimum set
 *    of partitions which must be scanned to satisfy these quals.  Returns
 *    the matching partitions in the form of a Relids set containing the
 *    partitions' RT indexes.
 *
 * Callers must ensure that 'rel' is a partitioned table.
 */
Relids
prune_append_rel_partitions(RelOptInfo *rel)
{
  Relids    result;
  List     *clauses = rel->baserestrictinfo;
  List     *pruning_steps;
  GeneratePruningStepsContext gcontext;
  PartitionPruneContext context;
  Bitmapset  *partindexes;
  int      i;

  Assert(clauses != NIL);
  Assert(rel->part_scheme != NULL);

  /* If there are no partitions, return the empty set */
  if (rel->nparts == 0)
    return NULL;

  /*
   * Process clauses to extract pruning steps that are usable at plan time.
   * If the clauses are found to be contradictory, we can return the empty
   * set.
   */
  gen_partprune_steps(rel, clauses, PARTTARGET_PLANNER,
            &gcontext);
  if (gcontext.contradictory)
    return NULL;
  pruning_steps = gcontext.steps;

  /* Set up PartitionPruneContext */
  context.strategy = rel->part_scheme->strategy;
  context.partnatts = rel->part_scheme->partnatts;
  context.nparts = rel->nparts;
  context.boundinfo = rel->boundinfo;
  context.partcollation = rel->part_scheme->partcollation;
  context.partsupfunc = rel->part_scheme->partsupfunc;
  context.stepcmpfuncs = (FmgrInfo *) palloc0(sizeof(FmgrInfo) *
                        context.partnatts *
                        list_length(pruning_steps));
  context.ppccontext = CurrentMemoryContext;

  /* These are not valid when being called from the planner */
  context.partrel = NULL;
  context.planstate = NULL;
  context.exprstates = NULL;

  /* Actual pruning happens here. */
  partindexes = get_matching_partitions(&context, pruning_steps);

  /* Add selected partitions' RT indexes to result. */
  i = -1;
  result = NULL;
  while ((i = bms_next_member(partindexes, i)) >= 0)
    result = bms_add_member(result, rel->part_rels[i]->relid);

  return result;
}

3）对结果集执行APPEND,作为最终结果输出，这和其他表append操作一致，使用ExecInitAppend和ExecAppend函数。

/* ----------------------------------------------------------------
 *     ExecAppend
 *
 *    Handles iteration over multiple subplans.
 * ----------------------------------------------------------------
 */
static TupleTableSlot *
ExecAppend(PlanState *pstate)
{
  AppendState *node = castNode(AppendState, pstate);

  if (node->as_whichplan < 0)
  {
    /*
     * If no subplan has been chosen, we must choose one before
     * proceeding.
     */
    if (node->as_whichplan == INVALID_SUBPLAN_INDEX &&
      !node->choose_next_subplan(node))
      return ExecClearTuple(node->ps.ps_ResultTupleSlot);

    /* Nothing to do if there are no matching subplans */
    else if (node->as_whichplan == NO_MATCHING_SUBPLANS)
      return ExecClearTuple(node->ps.ps_ResultTupleSlot);
  }

  for (;;)
  {
    PlanState  *subnode;
    TupleTableSlot *result;

    CHECK_FOR_INTERRUPTS();

    /*
     * figure out which subplan we are currently processing
     */
    Assert(node->as_whichplan >= 0 && node->as_whichplan < node->as_nplans);
    subnode = node->appendplans[node->as_whichplan];

    /*
     * get a tuple from the subplan
     */
    result = ExecProcNode(subnode);

    if (!TupIsNull(result))
    {
      /*
       * If the subplan gave us something then return it as-is. We do
       * NOT make use of the result slot that was set up in
       * ExecInitAppend; there's no need for it.
       */
      return result;
    }

    /* choose new subplan; if none, we're done */
    if (!node->choose_next_subplan(node))
      return ExecClearTuple(node->ps.ps_ResultTupleSlot);
  }
}

4.3 分区表写入

分区表写入分为两个阶段，一个是查找到要写入的分区，然后就是正常去做写入，下面来看查找分区的函数。

/*
 * ExecPrepareTupleRouting --- prepare for routing one tuple
 *
 * Determine the partition in which the tuple in slot is to be inserted,
 * and modify mtstate and estate to prepare for it.
 *
 * Caller must revert the estate changes after executing the insertion!
 * In mtstate, transition capture changes may also need to be reverted.
 *
 * Returns a slot holding the tuple of the partition rowtype.
 */
static TupleTableSlot *
ExecPrepareTupleRouting(ModifyTableState *mtstate,
            EState *estate,
            PartitionTupleRouting *proute,
            ResultRelInfo *targetRelInfo,
            TupleTableSlot *slot)
{
  ModifyTable *node;
  int      partidx;
  ResultRelInfo *partrel;
  HeapTuple  tuple;

  /*
   * Determine the target partition.  If ExecFindPartition does not find a
   * partition after all, it doesn't return here; otherwise, the returned
   * value is to be used as an index into the arrays for the ResultRelInfo
   * and TupleConversionMap for the partition.
   */
  partidx = ExecFindPartition(targetRelInfo,
                proute->partition_dispatch_info,
                slot,
                estate);
  Assert(partidx >= 0 && partidx < proute->num_partitions);

  /*
   * Get the ResultRelInfo corresponding to the selected partition; if not
   * yet there, initialize it.
   */
  partrel = proute->partitions[partidx];
  if (partrel == NULL)
    partrel = ExecInitPartitionInfo(mtstate, targetRelInfo,
                    proute, estate,
                    partidx);

  /*
   * Check whether the partition is routable if we didn't yet
   *
   * Note: an UPDATE of a partition key invokes an INSERT that moves the
   * tuple to a new partition.  This check would be applied to a subplan
   * partition of such an UPDATE that is chosen as the partition to route
   * the tuple to.  The reason we do this check here rather than in
   * ExecSetupPartitionTupleRouting is to avoid aborting such an UPDATE
   * unnecessarily due to non-routable subplan partitions that may not be
   * chosen for update tuple movement after all.
   */
  if (!partrel->ri_PartitionReadyForRouting)
  {
    /* Verify the partition is a valid target for INSERT. */
    CheckValidResultRel(partrel, CMD_INSERT);

    /* Set up information needed for routing tuples to the partition. */
    ExecInitRoutingInfo(mtstate, estate, proute, partrel, partidx);
  }

  /*
   * Make it look like we are inserting into the partition.
   */
  estate->es_result_relation_info = partrel;

  /* Get the heap tuple out of the given slot. */
  tuple = ExecMaterializeSlot(slot);

  /*
   * If we're capturing transition tuples, we might need to convert from the
   * partition rowtype to parent rowtype.
   */
  if (mtstate->mt_transition_capture != NULL)
  {
    if (partrel->ri_TrigDesc &&
      partrel->ri_TrigDesc->trig_insert_before_row)
    {
      /*
       * If there are any BEFORE triggers on the partition, we'll have
       * to be ready to convert their result back to tuplestore format.
       */
      mtstate->mt_transition_capture->tcs_original_insert_tuple = NULL;
      mtstate->mt_transition_capture->tcs_map =
        TupConvMapForLeaf(proute, targetRelInfo, partidx);
    }
    else
    {
      /*
       * Otherwise, just remember the original unconverted tuple, to
       * avoid a needless round trip conversion.
       */
      mtstate->mt_transition_capture->tcs_original_insert_tuple = tuple;
      mtstate->mt_transition_capture->tcs_map = NULL;
    }
  }
  if (mtstate->mt_oc_transition_capture != NULL)
  {
    mtstate->mt_oc_transition_capture->tcs_map =
      TupConvMapForLeaf(proute, targetRelInfo, partidx);
  }

  /*
   * Convert the tuple, if necessary.
   */
  ConvertPartitionTupleSlot(proute->parent_child_tupconv_maps[partidx],
                tuple,
                proute->partition_tuple_slot,
                &slot);

  /* Initialize information needed to handle ON CONFLICT DO UPDATE. */
  Assert(mtstate != NULL);
  node = (ModifyTable *) mtstate->ps.plan;
  if (node->onConflictAction == ONCONFLICT_UPDATE)
  {
    Assert(mtstate->mt_existing != NULL);
    ExecSetSlotDescriptor(mtstate->mt_existing,
                RelationGetDescr(partrel->ri_RelationDesc));
    Assert(mtstate->mt_conflproj != NULL);
    ExecSetSlotDescriptor(mtstate->mt_conflproj,
                partrel->ri_onConflict->oc_ProjTupdesc);
  }

  return slot;
}

4.4 分区表删除

分区表的删除即为先删除其分区，然后整体删除。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/908797.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

RHCSA课后练习3（网络与磁盘）

RHCSA课后练习3（网络与磁盘）

1、配置网络&#xff1a;为网卡添加一个本网段IPV4地址&#xff0c;x.x.x.123 涉及的知识点 配置网络&#xff1a; ens160&#xff1a;en---表示以太网 wl---表示无线局域网 ww---表示无线广域网 注意&#xff1a;一个网络接口&#xff0c;可以有多个网络连接&#xff0c;但…
阅读更多...
开发人员需要知道的 20个Git命令行技巧

开发人员需要知道的 20个Git命令行技巧

前言 大多数开发人员每天都会使用 Git&#xff0c;但许多人只是对其功能略知一二。 学习一些 git 命令行技巧可以改变游戏规则&#xff0c;让你更高效、更有成效&#xff0c;对版本控制更有信心。 那么&#xff0c;让我们深入了解每个开发人员工具包中都应该有的 20 个 Git …
阅读更多...
第十一章 综合案例--“精品课程网站“开发

第十一章 综合案例--“精品课程网站“开发

1.网站的开发流程 网站开发流程通常分为几个关键阶段&#xff0c;每个阶段都有其特定的任务和目标。以下是一个典型的网站开发流程&#xff1a; 1. 需求分析 目标设定&#xff1a;明确网站的目标和目的。 受众研究&#xff1a;确定目标用户&#xff0c;了解他们的需求和偏好。…
阅读更多...
VSCode 1.82之后的vscode server离线安装

VSCode 1.82之后的vscode server离线安装

概述 因为今天在公司开发项目的时候&#xff0c;需要离线配置vscode远程开发环境&#xff0c; 根据参考链接1配置了一遍&#xff0c;不管怎么重启&#xff0c;VSCODE都还是提示下载vscode server&#xff0c;后面在官方issue上找到了解决方案 解决方案 修改Remote SSH的配置…
阅读更多...
Linux和，FreeRTOS 任务调度原理，r0-r15寄存器，以及移植freertos（一）

Linux和，FreeRTOS 任务调度原理，r0-r15寄存器，以及移植freertos（一）

目录、 1、r0-r15寄存器&#xff0c;保护现场&#xff0c;任务切换的原理 2、freertos移植 3、freertos的任务管理。 一、前言 写这篇文章的目的&#xff0c;是之前面试官&#xff0c;刚好问到我&#xff0c;移植FreeRTOS 到mcu&#xff0c;需要做哪些步骤&#xff0c;当时回…
阅读更多...
「Mac畅玩鸿蒙与硬件28」UI互动应用篇5 - 滑动选择器实现

「Mac畅玩鸿蒙与硬件28」UI互动应用篇5 - 滑动选择器实现

本篇将带你实现一个滑动选择器应用&#xff0c;用户可以通过滑动条选择不同的数值&#xff0c;并实时查看选定的值和提示。这是一个学习如何使用 Slider 组件、状态管理和动态文本更新的良好实践。 关键词 UI互动应用Slider 组件状态管理动态数值更新用户交互 一、功能说明 在…
阅读更多...
云服务器防火墙设置方法

云服务器防火墙设置方法

云服务器防火墙设置方法通常包括&#xff1a;第一步&#xff1a;登录控制台&#xff0c;第二步&#xff1a;配置安全组规则&#xff0c;第三步&#xff1a;添加和编辑规则&#xff0c;第四步&#xff1a;启用或停用规则&#xff0c;第五步&#xff1a;保存并应用配置。云服务器…
阅读更多...
数据中台一键大解析！

数据中台一键大解析！

自从互联玩企业掀起了数据中台风&#xff0c;数据中台这个点马上就火起来了&#xff0c;短短几年数据中台就得到了极高的热度&#xff0c;一大堆企业也在跟风做数据中台&#xff0c;都把数据中台作为企业数字化转型的救命稻草&#xff0c;可是如果我告诉你数据中台并不是万能钥…
阅读更多...
【第一个qt项目的实现和介绍以及程序分析】【正点原子】嵌入式Qt5 C++开发视频

【第一个qt项目的实现和介绍以及程序分析】【正点原子】嵌入式Qt5 C++开发视频

qt项目的实现和介绍 1.第一个qt项目  &#xff08;1).创建qt工程    [1].创建一个存放qt的目录    [2].新建一个qt工程    [3].编译第一个工程    发生错误时的解决方式 二.QT文件介绍  (1).工程中文件简单介绍  (2).项目文件代码流程介绍    [1].添…
阅读更多...
计算机网络：网络层 —— 网络地址转换 NAT

计算机网络：网络层 —— 网络地址转换 NAT

文章目录 网络地址转换 NAT 概述最基本的 NAT 方法NAT 转换表的作用 网络地址与端口号转换 NAPTNAT 和 NAPT 的缺陷 网络地址转换 NAT 概述 尽管因特网采用了无分类编址方法来减缓 IPv4 地址空间耗尽的速度&#xff0c;但由于因特网用户数量的急剧增长&#xff0c;特别是大量小…
阅读更多...
【算法】【优选算法】双指针（下）

【算法】【优选算法】双指针（下）

目录 一、611.有效三⻆形的个数1.1 左右指针解法1.2 暴力解法 二、LCR 179.查找总价格为目标值的两个商品2.1 左右指针解法2.2 暴力解法 三、15.三数之和3.1 左右指针解法3.2 暴力解法 四、18.四数之和4.1 左右指针解法4.2 暴力解法 一、611.有效三⻆形的个数 题目链接&#x…
阅读更多...
面试题分享11月1日

面试题分享11月1日

1、过滤器和拦截器的区别 过滤器是基于spring的 拦截器是基于Java Web的 2、session 和 cookie 的区别、关系 cookie session 存储位置 保存在浏览器 &#xff08;客户端&#xff09; 保存在服务器 存储数据大小 限制大小&#xff0c;存储数据约为4KB 不限制大小&…
阅读更多...
VR 创业之路：从《I Expect You To Die》到未来展望

VR 创业之路：从《I Expect You To Die》到未来展望

今年是 Reality Labs 成立 10 周年&#xff0c;Meta 每周都会与不同的 XR 先驱进行交流&#xff0c;探讨他们在行业中的经历、经验教训以及对未来的展望。本次&#xff0c;他们与游戏设计师、作家兼 Schell Games CEO Jesse Schell 进行了深入交谈&#xff0c;了解了他的个人故…
阅读更多...
【大数据学习 | kafka】简述kafka的消费者consumer

【大数据学习 | kafka】简述kafka的消费者consumer

1. 消费者的结构 能够在kafka中拉取数据进行消费的组件或者程序都叫做消费者。 这里面要涉及到一个动作叫做拉取。 首先我们要知道kafka这个消息队列主要的功能就是起到缓冲的作用&#xff0c;比如flume采集数据然后交给spark或者flink进行计算分析&#xff0c;但是flume采用的…
阅读更多...
​Controlnet作者新作IC-light V2：基于FLUX训练，支持处理风格化图像，细节远高于SD1.5。

​Controlnet作者新作IC-light V2：基于FLUX训练，支持处理风格化图像，细节远高于SD1.5。

大家好&#xff01;今天我要向大家介绍一个超级有趣的话题——Controlnet作者的新作IC-light V2&#xff01;这个工具基于FLUX训练&#xff0c;能够支持处理风格化图像&#xff0c;并且细节表现远高于SD1.5。 想象一下&#xff0c;你有一个强大的AI助手&#xff0c;它能够根据…
阅读更多...
危机来临前---- 力扣： 876

危机来临前---- 力扣： 876

危机即将来临 – 链表的中间节点 描述&#xff1a; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例&#xff1a; 何解&#xff1f; 1、遍历找到中间节点 &#xff1a; 这个之在回文链表中找…
阅读更多...
【AI绘画】ComfyUI - AnimateDiff基础教程和使用心得

【AI绘画】ComfyUI - AnimateDiff基础教程和使用心得

AnimateDiff是什么&#xff1f; AnimateDiff 是一个能够将个性化的文本转换为图像的扩展模型&#xff0c;它可以在无需特定调整的情况下实现动画效果。通过这个项目&#xff0c;用户可以将他们的想象力以高质量图像的形式展现出来&#xff0c;同时以合理的成本实现这一目标。随…
阅读更多...
【docker】docker 环境配置及安装

【docker】docker 环境配置及安装

本文介绍基于 官方存储库 docker 的环境配置、安装、代理配置、卸载等相关内容。 官方安装文档说明&#xff1a;https://docs.docker.com/engine/install/ubuntu/ 主机环境 宿主机环境 Ubuntu 20.04.6 LTS 安装步骤 添加相关依赖 sudo apt-get update sudo apt-get install…
阅读更多...
一二三应用开发平台自定义查询设计与实现系列3——通用化重构

一二三应用开发平台自定义查询设计与实现系列3——通用化重构

通用化重构 前面我们以一个实体为目标对象&#xff0c;完成了功能开发与调试。 在此基础上&#xff0c;我们对功能进行重构&#xff0c;使其成为平台的标准化、通用化的功能。 前端重构 首先&#xff0c;先把自定义组件挪到了平台公共组件目录下&#xff0c;如下&#xff1…
阅读更多...
国标GB28181视频平台EasyCVR私有化视频平台工地防盗视频监控系统方案

国标GB28181视频平台EasyCVR私有化视频平台工地防盗视频监控系统方案

一、方案背景 在当代建筑施工领域&#xff0c;安全监管和防盗监控是保障工程顺利进行和资产安全的关键措施。随着科技进步&#xff0c;传统的监控系统已不足以应对现代工地的安全挑战。因此&#xff0c;基于国标GB28181视频平台EasyCVR的工地防盗视频监控系统应运而生&#xf…
阅读更多...
最新文章

Copyright @ 2022~2023