MODELADO

db.githubUsers.aggregate(
[{
"$group":
{
_id: "$campoParaAgrupar",
otrocampo:{$sum: <slgo>}
}
}]);

CATALOGO DE PRODUCTOS

  •  Almacenar diferentes tipos de objetos con diferentes conjuntos de atributos.

esquema dinámico

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

Crear una tabla por cada categoría de producto.

CREATE TABLE `producto_audio_album` (
    `sku` char(8) NOT NULL,
    ...
    `artista` varchar(255) DEFAULT NULL,
    `genero_0` varchar(255) DEFAULT NULL,
    `genero_1` varchar(255) DEFAULT NULL,
    ...,
    PRIMARY KEY(`sku`))
...
CREATE TABLE `producto_pelicula` (
    `sku` char(8) NOT NULL,
    ...
    `titulo` varchar(255) DEFAULT NULL,
    `calificacion` char(8) DEFAULT NULL,
    ...,
    PRIMARY KEY(`sku`))
...

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

Crear una tabla por cada categoría de producto.

  • Debemos crear una tabla por cada nueva categoría de productos.
  • Debe adaptar explícitamente todas las consultas para el tipo exacto de producto.

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

 Una tabla para todas las categorías de productos y agregar nuevas columnas cada vez que necesite almacenar datos sobre un nuevo tipo de producto. 

CREATE TABLE `producto` (
    `sku` char(8) NOT NULL,
    ...
    `artista` varchar(255) DEFAULT NULL,
    `genero_0` varchar(255) DEFAULT NULL,
    `genero_1` varchar(255) DEFAULT NULL,
    ...
    `titulo` varchar(255) DEFAULT NULL,
    `calificacion` char(8) DEFAULT NULL,
    ...,
    PRIMARY KEY(`sku`))

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

 Una tabla para todas las categorías de productos y agregar nuevas columnas cada vez que necesite almacenar datos sobre un nuevo tipo de producto. 

Permite que las consultas individuales abarquen diferentes tipos de productos, pero a expensas del espacio.

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

Puede usar un patrón de "herencia de tabla múltiple" para representar atributos comunes en una tabla genérica de "producto", con algunas variaciones en las tablas de productos de categorías individuales.

CREATE TABLE `producto` (
    `sku` char(8) NOT NULL,
    `titulo` varchar(255) DEFAULT NULL,
    `descripcion` varchar(255) DEFAULT NULL,
    `precio`, ...
    PRIMARY KEY(`sku`))

CREATE TABLE `producto_audio_album` (
    `sku` char(8) NOT NULL,
    ...
    `artista` varchar(255) DEFAULT NULL,
    `genero_0` varchar(255) DEFAULT NULL,
    `genero_1` varchar(255) DEFAULT NULL,
    ...,
    PRIMARY KEY(`sku`),
    FOREIGN KEY(`sku`) REFERENCES `producto`(`sku`))
...
CREATE TABLE `producto_pelicula` (
    `sku` char(8) NOT NULL,
    ...
    `titulo` varchar(255) DEFAULT NULL,
    `calificacion` char(8) DEFAULT NULL,
    ...,
    PRIMARY KEY(`sku`),
    FOREIGN KEY(`sku`) REFERENCES `producto`(`sku`))
...

CATALOGO DE PRODUCTOS

MODELADO RELACIONAL

Puede usar un patrón de "herencia de tabla múltiple" para representar atributos comunes en una tabla genérica de "producto", con algunas variaciones en las tablas de productos de categorías individuales.

La herencia de tablas múltiples es más eficiente en espacio que la herencia de tablas simples y algo más flexible que la herencia de tablas concretas. Sin embargo, este modelo requiere una operación JOIN costosa para obtener todos los atributos relevantes relevantes para un producto.

CATALOGO DE PRODUCTOS

MODELADO  NO RELACIONAL

Al comienzo del documento, el esquema debe contener información general del producto, para facilitar las búsquedas de todo el catálogo. Luego, un sub-documento de detalles que contiene campos que varían entre los tipos de productos

Item

detalle

CATALOGO DE PRODUCTOS

MODELADO  NO RELACIONAL

{
  sku: "00e8da9b",
  type: "Audio Album",
  title: "A Love Supreme",
  description: "by John Coltrane",
  asin: "B0000A118M",

  shipping: {
    weight: 6,
    dimensions: {
      width: 10,
      height: 10,
      depth: 1
    },
  },

  pricing: {
    list: 1200,
    retail: 1100,
    savings: 100,
    pct_savings: 8
  },

  details: {
    title: "A Love Supreme [Original Recording Reissued]",
    artist: "John Coltrane",
    genre: [ "Jazz", "General" ],
        ...
    tracks: [
      "A Love Supreme Part I: Acknowledgement",
      "A Love Supreme Part II - Resolution",
      "A Love Supreme, Part III: Pursuance",
      "A Love Supreme, Part IV-Psalm"
    ],
  },
}

CATALOGO DE PRODUCTOS

MODELADO  NO RELACIONAL

{
  sku: "00e8da9d",
  type: "Film",
  ...,
  asin: "B000P0J0AQ",

  shipping: { ... },

  pricing: { ... },

  details: {
    title: "The Matrix",
    director: [ "Andy Wachowski", "Larry Wachowski" ],
    writer: [ "Andy Wachowski", "Larry Wachowski" ],
    ...,
    aspect_ratio: "1.66:1"
  },
}

CATALOGO DE PRODUCTOS

OPERACIONES

Encontrar Albums por género y organizarlos por año producido

query = db.products.find({'type':'Audio Album',
                          'details.genre': 'Jazz'})
query = query.sort([('details.issue_date', -1)])

Query que retorna los documentos por los productos de un especifico genero.

CATALOGO DE PRODUCTOS

OPERACIONES

Encontrar Albums por género y organizarlos por año producido

db.products.ensure_index([
    ('type', 1),
    ('details.genre', 1),
    ('details.issue_date', -1)])

Cree un índice compuesto en todas las propiedades utilizadas en el filtro y en la clasificación:

CATALOGO DE PRODUCTOS

OPERACIONES

Encontrar productos organizados por porcentaje de descuento descendente

query = db.products.find( { 'pricing.pct_savings': {'$gt': 25 })
query = query.sort([('pricing.pct_savings', -1)])

//Indexando
b.products.ensure_index('pricing.pct_savings')

Si bien la mayoría de las búsquedas serán para un tipo particular de producto (por ejemplo, álbum, película, etc.) en algunas situaciones, es posible que desee devolver todos los productos en un rango de precios determinado o un porcentaje de descuento

CATALOGO DE PRODUCTOS

OPERACIONES

Encuentra películas basadas en actor estelar

query = db.products.find({'type': 'Film',
                          'details.actor': 'Keanu Reeves'})
query = query.sort([('details.issue_date', -1)])

Utilice la siguiente consulta para seleccionar documentos dentro de los detalles de un tipo de producto específico (es decir, película) del producto (una película) para encontrar productos que contengan un cierto valor (es decir, un actor específico en el campo details.actor) con los resultados ordenados por fecha descendente:

CATALOGO DE PRODUCTOS

OPERACIONES

Encuentra películas con una palabra particular en el título

import re
re_hacker = re.compile(r'.*hacker.*', re.IGNORECASE)

query = db.products.find({'type': 'Film', 'title': re_hacker})
query = query.sort([('details.issue_date', -1)])

Independientemente del motor de la base de datos, para recuperar esta información, el sistema necesitará escanear algunos documentos o registros para satisfacer esta consulta.

CATALOGO DE PRODUCTOS

OPERACIONES

Encuentra películas con una palabra particular en el título

query = db.products.find({
    'type': 'Film',
    'title': {'$regex': '.*hacker.*', '$options':'i'}})
query = query.sort([('details.issue_date', -1)])

Independientemente del motor de la base de datos, para recuperar esta información, el sistema necesitará escanear algunos documentos o registros para satisfacer esta consulta.

ADMINISTRADOR DE INVENTARIO

def add_item_to_cart(cart_id, sku, qty, details):
    now = datetime.utcnow()

    # Make sure the cart is still active and add the line item
    result = db.cart.update(
        {'_id': cart_id, 'status': 'active' },
        { '$set': { 'last_modified': now },
          '$push': {
              'items': {'sku': sku, 'qty':qty, 'details': details } } },
        w=1)
    if not result['updatedExisting']:
        raise CartInactive()

    # Update the inventory
    result = db.inventory.update(
        {'_id':sku, 'qty': {'$gte': qty}},
        {'$inc': {'qty': -qty},
         '$push': {
             'carted': { 'qty': qty, 'cart_id':cart_id,
                         'timestamp': now } } },
        w=1)
    if not result['updatedExisting']:
        # Roll back our cart update
        db.cart.update(
            {'_id': cart_id },
            { '$pull': { 'items': {'sku': sku } } })
        raise InadequateInventory()

Añadir un item al carrito

def update_quantity(cart_id, sku, old_qty, new_qty):
    now = datetime.utcnow()
    delta_qty = new_qty - old_qty

    # Make sure the cart is still active and add the line item
    result = db.cart.update(
        {'_id': cart_id, 'status': 'active', 'items.sku': sku },
        {'$set': {
             'last_modified': now,
             'items.$.qty': new_qty },
        },
        w=1)
    if not result['updatedExisting']:
        raise CartInactive()

    # Update the inventory
    result = db.inventory.update(
        {'_id':sku,
         'carted.cart_id': cart_id,
         'qty': {'$gte': delta_qty} },
        {'$inc': {'qty': -delta_qty },
         '$set': { 'carted.$.qty': new_qty, 'timestamp': now } },
        w=1)
    if not result['updatedExisting']:
        # Roll back our cart update
        db.cart.update(
            {'_id': cart_id, 'items.sku': sku },
            {'$set': { 'items.$.qty': old_qty } })
        raise InadequateInventory()

Modificar la cantidad en el carrito

def checkout(cart_id):
    now = datetime.utcnow()

    # Make sure the cart is still active and set to 'pending'. Also
    #     fetch the cart details so we can calculate the checkout price
    cart = db.cart.find_and_modify(
        {'_id': cart_id, 'status': 'active' },
        update={'$set': { 'status': 'pending','last_modified': now } } )
    if cart is None:
        raise CartInactive()

    # Validate payment details; collect payment
    try:
        collect_payment(cart)
        db.cart.update(
            {'_id': cart_id },
            {'$set': { 'status': 'complete' } } )
        db.inventory.update(
            {'carted.cart_id': cart_id},
            {'$pull': {'cart_id': cart_id} },
            multi=True)
    except:
        db.cart.update(
            {'_id': cart_id },
            {'$set': { 'status': 'active' } } )
        raise

La operación de pago debe: validar el método de pago y eliminar los artículos en el carrito después de que la transacción tenga éxito.

def expire_carts(timeout):
    now = datetime.utcnow()
    threshold = now - timedelta(seconds=timeout)

    # Lock and find all the expiring carts
    db.cart.update(
        {'status': 'active', 'last_modified': { '$lt': threshold } },
        {'$set': { 'status': 'expiring' } },
        multi=True )

    # Actually expire each cart
    for cart in db.cart.find({'status': 'expiring'}):

        # Return all line items to inventory
        for item in cart['items']:
            db.inventory.update(
                { '_id': item['sku'],
                  'carted.cart_id': cart['id'],
                  'carted.qty': item['qty']
                },
                {'$inc': { 'qty': item['qty'] },
                 '$pull': { 'carted': { 'cart_id': cart['id'] } } })

        db.cart.update(
            {'_id': cart['id'] },
            {'$set': { 'status': 'expired' })

Devolución al inventario cuando un carro expira

M

By nychi713

Made with Slides.com

M

  • 556

More from nychi713