"""
我们以task tracking system为例:
如果使用了two-way-referencing, 当然你从两种object的视角都能享受referencing的
benefit。但是请注意, 每当你要修改一个task和person的关系时, 你必须执行两个update。
而这意味着, **无法在一个atomic(原子操作)** 内完成这个update。
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import pymongo
import faker, random
import time
person = test.__getattr__("person")
tasks = test.__getattr__("tasks")
def insert_test_data():
person.remove()
tasks.remove()
fake = faker.Factory.create()
n_person = 5
n_task = 10
person_data = list()
tasks_data = list()
task_id = 0
for i in range(n_person):
con:
- 对embedded document中的项查询无法利用索引
- 对embedded document的查询很不方便, 例如在: 一个person有多个task, task有
due time。那么当查询 "在明天due的所有task" 就不是很方便, 在别的设计中完全可以
更简单
- 由于16MB Size限制, embedded document的数量不可以太多
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time
person = test.__getattr__("person")
def insert_test_data():
person.remove()
fake = faker.Factory.create()
n_person = 1000
person_data = [
{
"name": fake.name(),
"ssn": fake.ssn(),
"address": [
{
"street": fake.street_address(),
"city": fake.city(),
"state": fake.state(),
- 潜在地实现了many-to-many。从one-to-many中的many视角查询时, 只需要使用array
operation query即可。
con:
- 从one的视角查询时, 只能获得many对象的primary_key, 如果需要获得完整的many对象,
需要再做一次application-level join查询。
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time
products = test.__getattr__("products")
parts = test.__getattr__("parts")
def insert_test_data():
products.remove()
parts.remove()
fake = faker.Factory.create()
n_product = 20
n_part = 100
parts_data = [{
"_id": i + 1,
"partno": fake.ean(),
"name": fake.word(),
- 潜在地实现了many-to-many。从one-to-many中的many视角查询时, 只需要使用array
operation query即可。
con:
- 从one的视角查询时, 只能获得many对象的primary_key, 如果需要获得完整的many对象,
需要再做一次application-level join查询。
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time
products = test.__getattr__("products")
parts = test.__getattr__("parts")
def insert_test_data():
products.remove()
parts.remove()
fake = faker.Factory.create()
n_product = 20
n_part = 100
parts_data = [
{
"_id": i + 1,
"partno": fake.ean(),
"name": fake.word(),
- 潜在地实现了many-to-many。从one-to-many中的many视角查询时, 只需要使用array
operation query即可。
con:
- 从one的视角查询时, 只能获得many对象的primary_key, 如果需要获得完整的many对象,
需要再做一次application-level join查询。
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time
items = test.__getattr__("items")
tags = test.__getattr__("tags")
def insert_test_data():
items.remove()
tags.remove()
fake = faker.Factory.create()
n_items = 100
n_tags = 100
tags_data = [
{
"_id": i + 1,
"name": fake.word(),
} for i in range(n_tags)
pro:
con:
- 从one视角做查询时性能不会很高
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time, datetime
hosts = test.__getattr__("hosts")
logs = test.__getattr__("logs")
def insert_test_data():
hosts.remove()
logs.remove()
fake = faker.Factory.create()
n_host = 3
n_log = 1000
host_data = [{
"_id": i + 1,
"name": fake.url(),
"ipaddr": fake.ipv4(),
con:
- 对embedded document中的项查询无法利用索引
- 对embedded document的查询很不方便, 例如在: 一个person有多个task, task有
due time。那么当查询 "在明天due的所有task" 就不是很方便, 在别的设计中完全可以
更简单
- 由于16MB Size限制, embedded document的数量不可以太多
"""
from __future__ import print_function, unicode_literals
from database import test
from pprint import pprint
import faker, random
import time
person = test.__getattr__("person")
def insert_test_data():
person.remove()
fake = faker.Factory.create()
n_person = 1000
person_data = [{
"name":
fake.name(),
"ssn":
fake.ssn(),
"address": [{
"street": fake.street_address(),
"city": fake.city(),