Deletes a custom field associated with this list.
972858
def delete_custom_field(self, custom_field_key):
        """"""
        custom_field_key = quote(custom_field_key, '')
        response = self._delete("/lists/%s/customfields/%s.json" %
                                (self.list_id, custom_field_key))
802073
function clearField(index, properties) {
        // Aliased fields reflect values on other fields and do not need to be cleared.
        if (properties.isAlias === true) {
            return;
        }

        // In case of object & array, they must be initialized immediately.
        if (properties.type === 'object') {
            this[properties.name].clear();

            // Native arrays are never used so that toArray can be globally supported.
            // Additionally, other properties such as unique rely on passing through SchemaObject.
        } else if (properties.type === 'array') {
            this[properties.name].length = 0;

            // Other field types can simply have their value set to undefined.
        } else {
            writeValue.call(this[_privateKey]._this, undefined, properties);
        }
    }
589325
private void cascadeMarkedForDeletion()
    {
        List alreadyPrepared = new ArrayList();
        for(int i = 0; i < markedForDeletionList.size(); i++)
        {
            ObjectEnvelope mod = (ObjectEnvelope) markedForDeletionList.get(i);
            // if the object wasn't associated with another object, start cascade delete
            if(!isNewAssociatedObject(mod.getIdentity()))
            {
                cascadeDeleteFor(mod, alreadyPrepared);
                alreadyPrepared.clear();
            }
        }
        markedForDeletionList.clear();
    }
306287
def remove_item(self, item, field_name=None):
        
        field_name = self._choose_field_name(field_name)
        related_manager = getattr(item, field_name)
        related_manager.remove(self)
606730
@Override
    public void deleteValuesForField() {
        int shardNo = m_tableDef.getShardNumber(m_dbObj);
        m_dbTran.deleteAllObjectsColumn(m_tableDef, m_dbObj.getObjectID(), shardNo);
    }
749244
def remove_field(self, field):
        
        new_field = FieldFactory(
            field,
        )
        new_field.set_table(self)
        new_field_identifier = new_field.get_identifier()
        for field in self.fields:
            if field.get_identifier() == new_field_identifier:
                self.fields.remove(field)
                return field
        return None
1195459
def delete(self, for_update=False):
        
        hash_key = self.get_hash_id()
        try:
            original_instance = self.load(hash_key, convert_key=False)
        except KeyError:
            return

        # Remove from the `all` index.
        all_index = self._query.all_index()
        all_index.remove(hash_key)

        # Remove from the secondary indexes.
        for field in self._indexes:
            for index in field.get_indexes():
                index.remove(original_instance)

        if not for_update:
            for field in self._fields.values():
                if isinstance(field, _ContainerField):
                    field._delete(self)

        # Remove the object itself.
        self.__database__.delete(hash_key)
203508
private void deleteObject(DBObject dbObj) {
        for (String fieldName : dbObj.getUpdatedFieldNames()) {
            FieldUpdater fieldUpdater = FieldUpdater.createFieldUpdater(this, dbObj, fieldName);
            fieldUpdater.deleteValuesForField();
        }
        m_dbTran.deleteObjectRow(m_tableDef, dbObj.getObjectID());
    }
929017
def delete(self):
        """"""
        ret = False
        q = self.query
        pk = self.pk
        if pk:
            pk_name = self.schema.pk.name
            self.query.is_field(pk_name, pk).delete()
            setattr(self, pk_name, None)

            # mark all the fields that still exist as modified
            self.reset_modified()
            for field_name in self.schema.fields:
                if getattr(self, field_name, None) != None:
                    self.modified_fields.add(field_name)

            ret = True

        return ret
467938
public function delFields()
    {
        $oSelectlist = oxNew(\OxidEsales\Eshop\Application\Model\SelectList::class);
        if ($oSelectlist->loadInLang($this->_iEditLang, $this->getEditObjectId())) {
            // Disable editing for derived items.
            if ($oSelectlist->isDerived()) {
                return;
            }

            $aDelFields = \OxidEsales\Eshop\Core\Registry::getConfig()->getRequestParameter("aFields");
            $this->aFieldArray = \OxidEsales\Eshop\Core\Registry::getUtils()->assignValuesFromText($oSelectlist->oxselectlist__oxvaldesc->getRawValue());

            if (is_array($aDelFields) && count($aDelFields)) {
                foreach ($aDelFields as $sDelField) {
                    $sDel = $this->parseFieldName($sDelField);
                    foreach ($this->aFieldArray as $sKey => $oField) {
                        if ($oField->name == $sDel) {
                            unset($this->aFieldArray[$sKey]);
                            break;
                        }
                    }
                }
                $this->save();
            }
        }
    }
469931
public void destroy()
    {   
        for (int i=_fields.size();i-->0;)
        {
            Field field=(Field)_fields.get(i);
            if (field!=null)
                field.destroy();
        }
        _fields=null;
        _index=null;
        _dateBuffer=null;
        _calendar=null;
        _dateReceive=null;
    }
295425
public void removeCacheField()
    {
        try {
            Record record = this.getOwner();
            Object objKey = record.getHandle(DBConstants.OBJECT_ID_HANDLE);
            m_hsCache.remove(objKey);
        } catch (DBException ex)    {
            ex.printStackTrace();
        }
    }
490611
public void clearField(final FieldDescriptorType descriptor) {
    fields.remove(descriptor);
    if (fields.isEmpty()) {
      hasLazyField = false;
    }
  }
1234043
@Override
    public void deleteValuesForField() {
        for (String targetObjID : m_dbObj.getFieldValues(m_fieldName)) {
            deleteLinkInverseValue(targetObjID);
        }
        if (m_linkDef.isSharded()) {
            deleteShardedLinkTermRows();
        }
    }
466519
public void setCustomFields(Map<String, String> fields) {
        clearCustomFields();
        for (String key : fields.keySet()) {
            CustomField f = new CustomField();
            f.setName(key);
            f.setValue(fields.get(key));
            customFields.add(f);
        }
    }
637547
def remove(self, record):
        """"""
        self._field.validate_value(record)
        del self._elements[record.id]
        self._sync_field()
1050818
function removeFieldsFromObj(data, fieldsToRemove) {
    _.each(fieldsToRemove, function (fieldToRemove) {

        // if field to remove is in the data, just remove it and go to the next one
        if (data[fieldToRemove]) {
            delete data[fieldToRemove];
            return true;
        }

        var fieldParts = fieldToRemove.split('.');
        var fieldPart;
        var dataPointer = data;
        var len = fieldParts.length;
        for (var i = 0; i < len; i++) {
            fieldPart = fieldParts[i];

            // if the field doesn't exist, break out of the loop
            if (!dataPointer[fieldPart]) {
                break;
            }
            // if we are at the end then delete the item from the updatedData
            else if (i === (len - 1)) {
                delete dataPointer[fieldPart];
            }
            // else move the pointer down the object tree and go to the next iteration
            else {
                dataPointer = dataPointer[fieldPart];
            }
        }

        return true;
    });

    return data;
}