按照SequoiaDB官网上的技术文档，搭建如下的集群环境，进行数据分区的实例。

1.  集群环境

SequoiaDB数据库软件安装在默认安装目录opt/sequoiadb下，搭建典型的三副本最小集群。

2.水平分区实践

水平分区操作是在集合空间上使用createCL函数建立集合的时候，使用该函数的可选项参数ShardingKey指定分区键和ShardingType指定分区方式，在建立集合完成后，使用split切分函数，对该集合所在的分区对应的数据复制组进行进一步的切分，使该集合中分区键在切分操作指定范围内的那一部分数据存储在新的数据复制组内，从而完成数据库数据的水平分区。

2.1分区键为hash方式的范围切分

按以下操作进行水平分区操作：

第一步：切换到sdbadmin用户，使用sdb命令进入SequoiaDB shell命令行,并连接上协调节点。

[root@s1 ~]# su - sdbadmin
[sdbadmin@s1 ~]$ sdb
Welcome to SequoiaDB shell!
help() for help, Ctrl+c or quit to exit
> var db = new Sdb("s1",11810);
Takes 0.11194s.

第二步：创建集合空间foo和集合bar，并指定可选项参数ShardingKey（分区键）为id和ShardingType（分区方式）为hash（默认）。

>db.createCS("foo")
 reateCL("bar",{ShardingKey:{"id":1},ShardingType:"hash"});
s1:11810.foo.bar
Takes 0.524424s.

第三步：使用数据库快照函数snapshot，指定第一个参数快照类型为SDB_SNAP_CATALOG（编目信息快照），查看数据库的编目信息，第二参数查找的条件为"Name":"foo.bar"，过滤查找到的信息，只查看集合“foo.bar”的信息。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo.bar"});
{
  "_id": {
    "$oid": "591b5fe87a2691226dcf1005"
  },
  "Name": "foo.bar",
  "Version": 1,
  "Attribute": 0,
  "AttributeDesc": "",
  "ShardingKey": {
    "id": 1
  },
  "EnsureShardingIndex": true,
  "ShardingType": "hash",
  "Partition": 4096,
  "InternalV": 3,
  "CataInfo": [
    {
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "": 0
      },
      "UpBound": {
        "": 4096
      }
    }
  ]
}
Return 1 row(s).
Takes 0.75046s.

该集合分区所在的数据复制组为datagroup3，这样虽然指定了分区键和分区方式，但集合中数据依然只会存储在上复制组datagroup3上，和不进行数据切分操作在性能上没有区别。

第四步：使用split函数对集合进行数据切分，将默认复制组上的数据的分区键为0~2048的那一部分数据，切分到复制组datagroup1上。

> db.foo.bar.split("datagroup3","datagroup1",{"id":0},{"id":2048});
Takes 5.181650s.

第五步：使用第三步的数据库快照函数snapshot，查看集合编目信息。检验切分是否成功。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo.bar"});
{
  "Attribute": 0,
  "AttributeDesc": "",
  "CataInfo": [
    {
      "ID": 1,
      "GroupID": 1000,
      "GroupName": "datagroup1",
      "LowBound": {
        "": 0
      },
      "UpBound": {
        "": 2048
      }
    },
    {
      "ID": 0,
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "": 2048
      },
      "UpBound": {
        "": 4096
      }
    }
  ],
  "EnsureShardingIndex": true,
  "InternalV": 3,
  "Name": "foo.bar",
  "Partition": 4096,
  "ShardingKey": {
    "id": 1
  },
  "ShardingType": "hash",
  "Version": 2,
  "_id": {
    "$oid": "591b5fe87a2691226dcf1005"
  }
}
Return 1 row(s).
Takes 0.48471s.

从查找到的结果可以看出，成功将分区键范围在0~2048的切分到了数据复制组datagroup1内，数据复制组datagroup3中分区键范围是剩下的2048~4096。切分成功。

第六步：插入一条数据，该数据的分区键id为5，由于分区键是hash的切分方式，落在那个分区由数据库内部的hash函数决定。

> db.foo.bar.insert({"id":5});
Takes 0.88344s.

第七步：查看插入的数据存储在了那个复制组内，使用数据库快照函数snapshot，指定第一个参数快照类型为SDB_SNAP_COLLECTIONS(集合快照)，查看数据库的集合快照，第二参数查找的条件为"Name":"foo.bar"，过滤查找到的信息，只查看集合“foo.bar”的信息，第三个参数为"Details.GroupName":"","Details.Group.TotalRecords":""，指定要查看的字段，只查看过滤后的集合信息的Details下的GroupName（复制组名称）和Group的TotalRecords（数据总量）信息。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"foo.bar"}
,{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup1",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    },
    {
      "GroupName": "datagroup3",
      "Group": [
        {
          "TotalRecords": 0
        },
        {
          "TotalRecords": 0
        },
        {
          "TotalRecords": 0
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.324421s.

插入的数据存储在了数据复制组datagroup1上，查看集群环境可知该复制组的主节点在s3上。

第八步：使用Sdb函数，直连数据复制组datagroup1的主节点s3:11910，查找出条记录。

> var node = new Sdb("s3",11910);
Takes 0.94229s.
> node.foo.bar.find();
{
  "_id": {
    "$oid": "591b624caa7694f209000000"
  },
  "id": 5
}
Return 1 row(s).
Takes 0.66147s.

第九步：插入一条数据，该数据的分区键id为3416435636。

> db.foo.bar.insert({"id":3416435636});
Takes 0.2518s.

第十步：重复上边第七步。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"foo.bar"},{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup1",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    },
    {
      "GroupName": "datagroup3",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.8895s.

分区键id为3416435636的数据存储在了数据复制组datagroup3上，该组的主节点在上s3上。

第十一步：重复第八步。接节点s3:11930，查找刚刚插入的数据。

> var node = new Sdb("s3",11930);
Takes 0.7072s.
> node.foo.bar.find();
{
  "_id": {
    "$oid": "591b63f9aa7694f209000001"
  },
  "id": 3416435636
}
Return 1 row(s).
Takes 0.65995s.

结果：分区键是hash的切分方式，SequoiaDB首先将分区键进行hash散列函数运算，计算分区键的hash值。再将记录存储在对应的某个分区内，落在那个分区由分区键经过hash函数计算后的值决定。该实践表明，进行水平分区后的数据会根据分区键进行hash函数运算后的值，将该记录存储在对应的复制组内，该复制组的分区范围包含这个运算后的值。

2.2 分区键为hash方式的百分比切分

第一步操作过程和5.2.1节的前一步一样。

第二步：建立集合bar2。

> db.foo.createCL("bar2",{ShardingKey:{"id":1},ShardingType:"hash"});
s1:11810.foo.bar2

第三步：和5.2.1节一样，只是查找的集合为bar2。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo.bar2"});
{
  "_id": {
    "$oid": "591b66397a2691226dcf1007"
  },
  "Name": "foo.bar2",
  "Version": 1,
  "Attribute": 0,
  "AttributeDesc": "",
  "ShardingKey": {
    "id": 1
  },
  "EnsureShardingIndex": true,
  "ShardingType": "hash",
  "Partition": 4096,
  "InternalV": 3,
  "CataInfo": [
    {
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "": 0
      },
      "UpBound": {
        "": 4096
      }
    }
  ]
}
Return 1 row(s).
Takes 0.1282s.

 集合分区建立在数据复制组datagroup3上，分区键的范围为0~4096。

第四步：使用split函数对集合进行数据切分，将默认复制组上的数据的分区键按百分之五十的比例，切分到复制组上。

> db.foo.bar2.split("datagroup3","datagroup1",50);
Takes 4.15402s.

第五步：使用第三步的数据库快照函数snapshot，查看集合编目信息。检验切分是否成功。

 > db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo.bar2"});
{
  "Attribute": 0,
  "AttributeDesc": "",
  "CataInfo": [
    {
      "ID": 0,
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "": 0
      },
      "UpBound": {
        "": 2048
      }
    },
    {
      "ID": 1,
      "GroupID": 1000,
      "GroupName": "datagroup1",
      "LowBound": {
        "": 2048
      },
      "UpBound": {
        "": 4096
      }
    }
  ],
  "EnsureShardingIndex": true,
  "InternalV": 3,
  "Name": "foo.bar2",
  "Partition": 4096,
  "ShardingKey": {
    "id": 1
  },
  "ShardingType": "hash",
  "Version": 2,
  "_id": {
    "$oid": "591b66397a2691226dcf1007"
  }
}
Return 1 row(s).
Takes 0.1096s.

成功将分区键范围在2048~4096的切分到了数据复制组datagroup1内，数据复制组datagroup3中分区键范围是剩下的0~2048。切分成功。

结果：成功将分区键范围在0~2048的切分到了数据复制组datagroup12内，数据

复制组datagroup1中分区键范围是剩下的2048~4096。切分成功。

2.3分区键为range方式的范围切分

第一步：切换到sdbadmin用户，使用sdb命令进入SequoiaDB shell命令行,并连接上协调节点。

[root@s1 ~]# su - sdbadmin
[sdbadmin@s1 ~]$ sdb
Welcome to SequoiaDB shell!
help() for help, Ctrl+c or quit to exit
> var db = new Sdb("s1",11810);
Takes 0.11194s.

第二步：创建集合空间foo2和集合bar，并指定可选项参数ShardingKey（分区键）为id和ShardingType（分区方式）为range。

>db.createCS("foo2").createCL("bar",{ShardingKey:{"id":1},ShardingType:"range"});
s1:11810.foo2.bar
Takes 0.489219s.

第三步：使用数据库快照函数snapshot，指定第一个参数快照类型为SDB_SNAP_CATALOG（编目信息快照），查看数据库的编目信息，第二参数查找的条件为"Name":" foo2.bar "，过滤查找到的信息，只查看集合“foo2. bar”的信息。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo2.bar"});
{
  "_id": {
    "$oid": "591b685f7a2691226dcf100a"
  },
  "Name": "foo2.bar",
  "Version": 1,
  "Attribute": 0,
  "AttributeDesc": "",
  "ShardingKey": {
    "id": 1
  },
  "EnsureShardingIndex": true,
  "ShardingType": "range",
  "CataInfo": [
    {
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "id": {
          "$minKey": 1
        }
      },
      "UpBound": {
        "id": {
          "$maxKey": 1
        }
      }
    }
  ]
}
Return 1 row(s).
Takes 0.1005s.

集和foo2.bar，分区区间为minKey和maxKey，在数据复制组datagroup3上，无上下限。这样虽然指定了分区键和分区方式，但集合中数据依然只会存储在datagroup3上，和不进行切分是一样的，因此进行下面的集合切分步骤。

第四步：使用split函数对集合进行数据切分，将默认复制组上的数据的分区键为~100的那一部分数据，切分到复制组datagroup1上。

>db.foo2.bar.split("datagroup3","datagroup1",{"id":{$minKey:1}},{"id":100})

Takes 5.60855s.

第五步：使用第三步的数据库快照函数snapshot，查看集合编目信息。检验切分是否成功。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo2.bar"});
{
  "Attribute": 0,
  "AttributeDesc": "",
  "CataInfo": [
    {
      "ID": 1,
      "GroupID": 1000,
      "GroupName": "datagroup1",
      "LowBound": {
        "id": {
          "$minKey": 1
        }
      },
      "UpBound": {
        "id": 100
      }
    },
    {
      "ID": 0,
      "GroupID": 1003,
      "GroupName": "datagroup3",
      "LowBound": {
        "id": 100
      },
      "UpBound": {
        "id": {
          "$maxKey": 1
        }
      }
    }
  ],
  "EnsureShardingIndex": true,
  "Name": "foo2.bar",
  "ShardingKey": {
    "id": 1
  },
  "ShardingType": "range",
  "Version": 2,
  "_id": {
    "$oid": "591b685f7a2691226dcf100a"
  }
}
Return 1 row(s).
Takes 0.49763s.

成功将分区键范围在100以下的切分到了数据复制组datagroup1内，数据复制组datagroup3中分区键范围是剩下100以上的。切分成功。

第六步：插入一条数据，该数据的分区键id为10，由于分区键是range的切分方式，落在那个分区由数分区键决定，该记录一定落在复制组datagroup1内。

> db.foo2.bar.insert({"id":10});
Takes 0.3142s.

第七步：查看插入的数据存储在了那个复制组内，使用数据库快照函数snapshot，指定第一个参数快照类型为SDB_SNAP_COLLECTIONS(集合快照)，查看数据库的集合快照，第二参数查找的条件为"Name":" foo2. bar "，过滤查找到的信息，只查看集合“foo2. bar”的信息，第三个参数为"Details.GroupName":"","Details.Group.TotalRecords":""，指定要查看的字段，只查看过滤后的集合信息的Details下的GroupName（复制组名称）和Group的TotalRecords（数据总量）信息。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"foo2.bar"},{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup1",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    },
    {
      "GroupName": "datagroup3",
      "Group": [
        {
          "TotalRecords": 0
        },
        {
          "TotalRecords": 0
        },
        {
          "TotalRecords": 0
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.8148s.

       分区键id为10的记录存储到了数据复制组datagroup1上，该复制组的主节点在主机s3上。

第八步：使用Sdb函数，直连数据复制组datagroup1的主节点s3:11910，读出该条记录。

> var node = new Sdb("s3",11910);
Takes 0.7667s.
> node.foo2.bar.find();
{
  "_id": {
    "$oid": "591b6a29aa7694f209000002"
  },
  "id": 10
}
Return 1 row(s).
Takes 0.2303s.

第九步：插入一条数据，该数据的分区键id为110

> db.foo2.bar.insert({"id":110});
Takes 0.23242s.

第十步：重复上边第七步。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"foo2.bar"},{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup1",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    },
    {
      "GroupName": "datagroup3",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.9129s.

分区键id为110的记录存储到了数据复制组datagroup3上，该复制组的主节点在主机s3上。

第十一步：使用Sdb函数，直连数据复制组datagroup3的主节点s3:11930，读出该条记录。

> var node = new Sdb("s3",11930);
Takes 0.6934s.
> node.foo2.bar.find();
{
  "_id": {
    "$oid": "591b6b2ce5f835655c000000"
  },
  "id": 110
}
Return 1 row(s).
Takes 0.2049s.

结果：分区键是range的切分方式，数据库直接进行对分区键的值进行映射到某个分区对应的复制组内。

2.4分区键为range方式的百分比切分

第一步操作过程和5.2.1节的前一步一样。

第二步：建立集合foo2.bar2。

>db.foo2.createCL("bar2",{ShardingKey:{"id":1},ShardingType:"range"});
s1:11810.foo2.bar2
Takes 0.481813s

第三步：和5.2.3节一样，只是查找的集合为foo2.bar2。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo2.bar2"});
{
  "_id": {
    "$oid": "591b6c437a2691226dcf100c"
  },
  "Name": "foo2.bar2",
  "Version": 1,
  "Attribute": 0,
  "AttributeDesc": "",
  "ShardingKey": {
    "id": 1
  },
  "EnsureShardingIndex": true,
  "ShardingType": "range",
  "CataInfo": [
    {
      "GroupID": 1001,
      "GroupName": "datagroup2",
      "LowBound": {
        "id": {
          "$minKey": 1
        }
      },
      "UpBound": {
        "id": {
          "$maxKey": 1
        }
      }
    }
  ]
}
Return 1 row(s).
Takes 0.1220s.

集合分区建立在数据复制组datagroup2上，分区键的范围为无上下限。

第四步：使用split函数对集合进行数据切分，将默认复制组上的数据的分区键按百分之五十的比例，切分到复制组上。集合是空的，无法进行百分比切分，找不到百分比切分点，需要先插入一条数据（id:1）后，切分。

> db.foo2.bar2.insert({"id":1});
Takes 0.3058s.
> db.foo2.bar2.split("datagroup2","datagroup1",50);
Takes 4.35786s.

第五步：使用第三步的数据库快照函数snapshot，查看集合编目信息。检验切分是否成功。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"foo2.bar2"});
{
  "Attribute": 0,
  "AttributeDesc": "",
  "CataInfo": [
    {
      "ID": 0,
      "GroupID": 1001,
      "GroupName": "datagroup2",
      "LowBound": {
        "id": {
          "$minKey": 1
        }
      },
      "UpBound": {
        "id": 1
      }
    },
    {
      "ID": 1,
      "GroupID": 1000,
      "GroupName": "datagroup1",
      "LowBound": {
        "id": 1
      },
      "UpBound": {
        "id": {
          "$maxKey": 1
        }
      }
    }
  ],
  "EnsureShardingIndex": true,
  "Name": "foo2.bar2",
  "ShardingKey": {
    "id": 1
  },
  "ShardingType": "range",
  "Version": 2,
  "_id": {
    "$oid": "591b6c437a2691226dcf100c"
  }
}
Return 1 row(s).
Takes 0.919s.

成功将分区键范围在1以上的切分到了数据复制组datagroup1内，数据复制组datagroup2中分区键范围是剩下的1以下。切分成功。

结果：切分后，datagroup1上的数据分区键范围上限为minKey，下限为1,datagroup3上的数据分区键范围上限为1，下限为maxKey。

2.5垂直分区实践

第一步：切换到sdbadmin用户，使用sdb命令进入SequoiaDB shell命令行,并连接上协调节点。

[root@s1 ~]# su - sdbadmin
[sdbadmin@s1 ~]$ sdb
Welcome to SequoiaDB shell!
help() for help, Ctrl+c or quit to exit
> var db = new Sdb("s1",11810);
Takes 0.11194s.

第二步：建立主表集合mcs.mcl，在建立集合mcl的时候，指定可选项分区键（ShardingKey）为dated，分区类型（ShardingType）为range，是否为主表（IsMainCL）为true。

>db.createCS("mcs").createCL("mcl",{ShardingKey:{"dated":1},ShardingType:"range",IsMainCL:true});
s1:11810.mcs.mcl
Takes 0.156618s.

第三步：建立两个子表集合mcs.mcl_1和mcs.mcl_2。

> db.mcs.createCL("mcl_1");
s1:11810.mcs.mcl_1
Takes 0.826850s.
> db.mcs.createCL("mcl_2");
s1:11810.mcs.mcl_2
Takes 0.706540s.

第四步：将子表关联到主表上，使用集合对象的attachCL函数，第一个参数为子集合名称，第二个参数为分区键范

围。
>db.mcs.mcl.attachCL("mcs.mcl_1",{LowBound:{dated:{$date:"2014-01-01"}},UpBound:{dated:{$date:"2014-02-01"}}});
Takes 0.206834s.
>db.mcs.mcl.attachCL("mcs.mcl_2",{LowBound:{dated:{$date:"2014-02-01"}},UpBound:{dated:{$date:"2014-03-01"}}});
Takes 0.46689s.

将2014年一月的数据存储在子表mcs.mcl_1中，二月的数据存储在子表mcs.mcl_中。

第五步：通过集合编目信息快照，查看系统编目中主表的信息。

> db.snapshot(SDB_SNAP_CATALOG,{"Name":"mcs.mcl"});
{
  "Attribute": 0,
  "AttributeDesc": "",
  "CataInfo": [
    {
      "ID": 1,
      "SubCLName": "mcs.mcl_1",
      "LowBound": {
        "dated": {
          "$date": "2014-01-01"
        }
      },
      "UpBound": {
        "dated": {
          "$date": "2014-02-01"
        }
      }
    },
    {
      "ID": 2,
      "SubCLName": "mcs.mcl_2",
      "LowBound": {
        "dated": {
          "$date": "2014-02-01"
        }
      },
      "UpBound": {
        "dated": {
          "$date": "2014-03-01"
        }
      }
    }
  ],
  "EnsureShardingIndex": true,
  "IsMainCL": true,
  "Name": "mcs.mcl",
  "ShardingKey": {
    "dated": 1
  },
  "ShardingType": "range",
  "Version": 3,
  "_id": {
    "$oid": "591b7d8d977e871630f91a3d"
  }
}
Return 1 row(s).
Takes 0.1708s.

第六步：在主表上插入一条数据dated:{$date:”2014-01-02”}，该数据预期存储在子表mcs.mcl_1中。

> db.mcs.mcl.insert({"dated":{$date:"2014-01-02"}});
Takes 0.60464s.

第七步：查看插入的数据存储在了那个子表内，使用数据库快照函数snapshot，指定第一个参数快照类型为SDB_SNAP_COLLECTIONS(集合快照)，查看数据库的集合快照，第二参数查找的条件为"Name":" mcs.mcl_1"，过滤查找到的信息，只查看集合“mcs.mcl_1”的信息，第三个参数为"Details.GroupName":"","Details.Group.TotalRecords":""，指定要查看的字段，只查看过滤后的集合信息的Details下的GroupName（复制组名称）和Group的TotalRecords（数据总量）信息。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"mcs.mcl_1"},{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup2",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.10059s.

 可以看到刚刚插入的数据是在子表mcs.mcl_1的复制组datagroup2上，数据复制组datagroup2的主节点在主机s3上。

第八步：通过Sdb，连接数据复制组datagroup2的主节点s3:11920，检查刚刚插入的数据。
> var node = new Sdb("s3",11920);
Takes 0.7566s.
> node.mcs.mcl_1.find();
{
  "_id": {
    "$oid": "591b80070b5da97b5c000001"
  },
  "dated": {
    "$date": "2014-01-02"
  }
}
Return 1 row(s).
Takes 0.2829s.

第九步：插入一条数据dated:{$date:”2014-02-02”}，该数据预期存储在子表mcs.mcl_2上。

> db.mcs.mcl.insert({"dated":{$date:"2014-02-02"}});
Takes 0.12586s.

第十步：同第七步，查看数据存储。

>db.snapshot(SDB_SNAP_COLLECTIONS,{"Name":"mcs.mcl_2"},{"Details.GroupName":"","Details.Group.TotalRecords":""});
{
  "Details": [
    {
      "GroupName": "datagroup3",
      "Group": [
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        },
        {
          "TotalRecords": 1
        }
      ]
    }
  ]
}
Return 1 row(s).
Takes 0.40022s.

可以看到刚刚插入的数据是在子表mcs.mcl_2的复制组datagroup3上，数据复制组datagroup3的主节点在主机s3上。

第十一步：通过Sdb，连接数据复制组datagroup3的主节点s3:11930，检查刚刚插入的数据。

> var node = new Sdb("s3",11930);
Takes 0.7153s.
> node.mcs.mcl_2.find();
{
  "_id": {
    "$oid": "591b90ceb241f36c5d000000"
  },
  "dated": {
    "$date": "2014-02-02"
  }
}
Return 1 row(s)

结果：垂直分区会将数据存储在不同的子集合中，各个子集合是主集合通过分区键的一个划分，使用一个统一的主表进行数据的操作和管理。

3. 混合分区

即将上垂直分区实例中的子集合指定分区键并将该分区键按照5.2节所述，进行水平分区操作，切分到不同分区中，并将分区指定到不同的复制组中，从而实现混合分区。