Exemplo n.º 1
0
    def insert(self, data, return_id=False):
        gae_data = {}
        opts = self.query.get_meta()
        indexes = get_indexes().get(self.query.model, {})
        unindexed_fields = indexes.get('unindexed', ())
        unindexed_cols = [
            opts.get_field(name).column for name in unindexed_fields
        ]
        kwds = {'unindexed_properties': unindexed_cols}
        for column, value in data.items():
            if column == opts.pk.column:
                if isinstance(value, basestring):
                    kwds['name'] = value
                else:
                    kwds['id'] = value
            elif isinstance(value, (tuple, list)) and not len(value):
                # gae does not store emty lists (and even does not allow passing empty
                # lists to Entity.update) so skip them
                continue
            else:
                gae_data[column] = value

        entity = Entity(self.query.get_meta().db_table, **kwds)
        entity.update(gae_data)
        key = Put(entity)
        return key.id_or_name()
Exemplo n.º 2
0
    def insert(self, data, return_id=False):
        gae_data = {}
        opts = self.query.get_meta()
        indexes = get_indexes().get(self.query.model, {})
        unindexed_fields = indexes.get('unindexed', ())
        unindexed_cols = [opts.get_field(name).column
                          for name in unindexed_fields]
        kwds = {'unindexed_properties': unindexed_cols}
        for column, value in data.items():
            if column == opts.pk.column:
                if isinstance(value, basestring):
                    kwds['name'] = value
                else:
                    kwds['id'] = value
            elif isinstance(value, (tuple, list)) and not len(value):
                # gae does not store emty lists (and even does not allow passing empty
                # lists to Entity.update) so skip them
                continue
            else:
                gae_data[column] = value

        entity = Entity(self.query.get_meta().db_table, **kwds)
        entity.update(gae_data)
        key = Put(entity)
        return key.id_or_name()
Exemplo n.º 3
0
    def update_entity(self, pk, pk_field):
        gae_query = self.build_query()
        entity = Get(self.ops.value_for_db(pk, pk_field))

        if not gae_query.matches_filters(entity):
            return

        for field, _, value in self.query.values:
            if hasattr(value, 'prepare_database_save'):
                value = value.prepare_database_save(field)
            else:
                value = field.get_db_prep_save(value,
                                               connection=self.connection)

            if hasattr(value, 'evaluate'):
                assert not value.negated
                value = ExpressionEvaluator(value,
                                            self.query,
                                            entity,
                                            allow_joins=False)

            if hasattr(value, 'as_sql'):
                value = value.as_sql(lambda n: n, self.connection)

            entity[field.column] = self.ops.value_for_db(value, field)

        Put(entity)
Exemplo n.º 4
0
    def insert(self, data_list, return_id=False):
        opts = self.query.get_meta()
        unindexed_fields = get_model_indexes(self.query.model)['unindexed']
        unindexed_cols = [
            opts.get_field(name).column for name in unindexed_fields
        ]

        entity_list = []
        for data in data_list:
            properties = {}
            kwds = {'unindexed_properties': unindexed_cols}
            for column, value in data.items():
                # The value will already be a db.Key, but the Entity
                # constructor takes a name or id of the key, and will
                # automatically create a new key if neither is given.
                if column == opts.pk.column:
                    if value is not None:
                        kwds['id'] = value.id()
                        kwds['name'] = value.name()

                # GAE does not store empty lists (and even does not allow
                # passing empty lists to Entity.update) so skip them.
                elif isinstance(value, (tuple, list)) and not len(value):
                    continue

                # Use column names as property names.
                else:
                    properties[column] = value

            entity = Entity(opts.db_table, **kwds)
            entity.update(properties)
            entity_list.append(entity)

        keys = Put(entity_list)
        return keys[0] if isinstance(keys, list) else keys
Exemplo n.º 5
0
 def txn(entity):
     entity = Get(entity.key())
     try:
         entity[self.to_column_name] = entity[self.from_column_name]
     except KeyError:
         return
     Put(entity)
Exemplo n.º 6
0
 def txn(entity):
     entity = Get(entity.key())
     try:
         del entity[column_name]
     except KeyError:
         return
     Put(entity)
Exemplo n.º 7
0
    def update_entity(self, pk):
        gae_query = self.build_query()
        key = create_key(self.query.get_meta().db_table, pk)
        entity = Get(key)
        if not gae_query.matches_filters(entity):
            return
        
        qn = self.quote_name_unless_alias
        update_dict = {}
        for field, o, value in self.query.values:
            if hasattr(value, 'prepare_database_save'):
                value = value.prepare_database_save(field)
            else:
                value = field.get_db_prep_save(value, connection=self.connection)
            
            if hasattr(value, "evaluate"):
                assert not value.negated
                assert not value.subtree_parents
                value = ExpressionEvaluator(value, self.query, entity,
                                                allow_joins=False)
                
            if hasattr(value, 'as_sql'):
                # evaluate expression and return the new value
                val = value.as_sql(qn, self.connection)
                update_dict[field] = val
            else:
                update_dict[field] = value

        for field, value in update_dict.iteritems():
            db_type = field.db_type(connection=self.connection)
            entity[qn(field.column)] = self.convert_value_for_db(db_type, value)

        key = Put(entity)
Exemplo n.º 8
0
    def insert(self, data, return_id=False):
        opts = self.query.get_meta()
        unindexed_fields = get_model_indexes(self.query.model)['unindexed']
        kwds = {'unindexed_properties': []}
        properties = {}
        for field, value in data.iteritems():

            # The value will already be a db.Key, but the Entity
            # constructor takes a name or id of the key, and will
            # automatically create a new key if neither is given.
            if field.primary_key:
                if value is not None:
                    kwds['id'] = value.id()
                    kwds['name'] = value.name()

            # GAE does not store empty lists (and even does not allow
            # passing empty lists to Entity.update) so skip them.
            elif isinstance(value, (tuple, list)) and not len(value):
                continue

            # Use column names as property names.
            else:
                properties[field.column] = value

            if field in unindexed_fields:
                kwds['unindexed_properties'].append(field.column)

        entity = Entity(opts.db_table, **kwds)
        entity.update(properties)
        return Put(entity)
Exemplo n.º 9
0
 def txn():
     existing = Get([new_key])[0]
     if existing and not self.overwrite_existing:
         return
     if isinstance(entity.key().id_or_name(), (int, long)):
         reserve_id(self.to_kind,
                    entity.key().id_or_name(), self.to_namespace)
     new_entity = clone_entity(entity, new_key)
     Put(new_entity)
Exemplo n.º 10
0
    def insert(self, data, return_id=False):
        kwds = {}
        gae_data = {}
        for column, value in data.items():
            if column == self.query.get_meta().pk.column:
                if isinstance(value, basestring):
                    kwds['name'] = value
                else:
                    kwds['id'] = value
            elif isinstance(value, (tuple, list)) and not len(value):
                # gae does not store emty lists (and even does not allow passing empty
                # lists to Entity.update) so skip them
                continue
            else:
                gae_data[column] = value

        entity = Entity(self.query.get_meta().db_table, **kwds)
        entity.update(gae_data)
        key = Put(entity)
        return key.id_or_name()
Exemplo n.º 11
0
    def insert(self, data, return_id=False):
        gae_data = {}
        opts = self.query.get_meta()
        unindexed_fields = get_model_indexes(self.query.model)['unindexed']
        unindexed_cols = [opts.get_field(name).column
                          for name in unindexed_fields]
        kwds = {'unindexed_properties': unindexed_cols}
        for column, value in data.items():
            if column == opts.pk.column:
                if isinstance(value, GAEKey):
                    if value.parent_key() and value.parent_key().has_real_key():
                        kwds['parent'] = value.parent_key().real_key()
                    if isinstance(value.id_or_name(), basestring):
                        kwds['name'] = value.id_or_name()
                    elif value.id_or_name() is not None:
                        kwds['id'] = value.id_or_name()
                elif isinstance(value, Key):
                    kwds['parent'] = value.parent()
                    if value.name():
                        kwds['name'] = value.name()
                    elif value.id():
                        kwds['id'] = value.id()
                elif isinstance(value, basestring):
                    kwds['name'] = value
                else:
                    kwds['id'] = value
            elif isinstance(value, (tuple, list)) and not len(value):
                # gae does not store empty lists (and even does not allow passing empty
                # lists to Entity.update) so skip them
                continue
            else:
                gae_data[column] = value

        entity = Entity(opts.db_table, **kwds)
        entity.update(gae_data)
        key = Put(entity)

        if not isinstance(opts.pk, GAEKeyField):
            key = key.id_or_name()
        
        return key
Exemplo n.º 12
0
 def txn():
     try:
         existing = Get(new_key)
     except datastore_errors.EntityNotFoundError:
         existing = None
     if existing and not self.overwrite_existing:
         return
     if isinstance(entity.key().id_or_name(), (int, long)):
         reserve_id(self.to_kind,
                    entity.key().id_or_name(), self.namespace)
     new_entity = clone_entity(entity, new_key)
     Put(new_entity)
Exemplo n.º 13
0
def bulk_create(instances, connection=None):
    """
        Uses AppEngine's bulk Put() call on a number of instances
        this will NOT call save() but it will return the instances
        with their primary_key populated (unlike Django's bulk_create)
    """
    if connection is None:
        from django.db import connection

    from .fields import AncestorKey

    def prepare_entity(instance):
        if isinstance(instance.pk, AncestorKey):
            parent = instance.pk._parent_key
        else:
            parent = None

        result = Entity(instance._meta.db_table, parent=parent)

        for field in instance._meta.fields:
            if field.name == "id":
                continue

            value = field.pre_save(instance, True)
            setattr(instance, field.name, value)
            value = field.get_db_prep_save(getattr(instance, field.attname),
                                           connection)
            if isinstance(value, (list, set)):
                value = list(value)
                if not value:
                    value = None

            result[field.column] = value
        return result

    entities = [prepare_entity(x) for x in instances]

    keys = Put(entities)

    assert (len(keys) == len(entities))

    for i, key in enumerate(keys):
        assert (key)

        if key.parent():
            instances[i]._parent_key = key.parent()
            instances[i].pk.key_id = key.id_or_name()
        else:
            instances[i].id = key.id_or_name()

    return instances
Exemplo n.º 14
0
 def txn(entity):
     entity = Get(entity.key())
     entity[column_name] = value
     Put(entity)