Insert value in the keystore. Return the UUID key.
6902
def insert(self, value):
        ""
        key = str(uuid4())
        self.set(key, value)
        return key
641383
def insert_query(connection, publicId, aead, keyhandle, aeadobj):
    """"""

    # turn the keyhandle into an integer
    keyhandle = key_handle_to_int(keyhandle)
    if not keyhandle == aead.key_handle:
        print("WARNING: keyhandle does not match aead.key_handle")
        return None

    # creates the query object
    try:
        sql = aeadobj.insert().values(public_id=publicId, keyhandle=aead.key_handle, nonce=aead.nonce, aead=aead.data)
        # insert the query
        result = connection.execute(sql)
        return result
    except sqlalchemy.exc.IntegrityError:
        pass
    return None
1234185
def prepare_uuid(data, schema):
    
    if isinstance(data, uuid.UUID):
        return str(data)
    else:
        return data
890038
def increment(self, key, value=1):
        
        data, time_ = self._get_payload(key)

        integer = int(data) + value

        self.put(key, integer, int(time_))

        return integer
910864
def set(self, id, value):
        
        return self.kv.set(self.key_name(id), value)
601136
def get(self, key):
    '''
    '''
    self.logger.info('%s: get %s' % (self, key))
    value = super(LoggingDatastore, self).get(key)
    self.logger.debug('%s: %s' % (self, value))
    return value
701048
public KeyValueStoreUpdate update(String key, String value) {
		actions.add(new Update(key, value));
		return this;
	}
217300
def uuid2buid(value):
    
    if six.PY3:  # pragma: no cover
        return urlsafe_b64encode(value.bytes).decode('utf-8').rstrip('=')
    else:
        return six.text_type(urlsafe_b64encode(value.bytes).rstrip('='))
157975
private V putImpl(K key, V value)
  {
    V item = null;

    int hash = key.hashCode() & _mask;
    int count = _values.length;

    for (; count > 0; count--) {
      item = _values[hash];

      // No matching item, so create one
      if (item == null) {
        _keys[hash] = key;
        _values[hash] = value;
        _size++;

        return null;
      }

      // matching item gets replaced
      if (_keys[hash].equals(key)) {
        _values[hash] = value;

        return item;
      }

      hash = (hash + 1) & _mask;
    }

    throw new IllegalStateException();
  }
649003
def insert(self, key, value, data={}):
        
        if value < self.min_value or value > self.max_value:
            raise BoundsError('item value out of bounds')

        item = self.Item(key, value, data)
        index = self.get_bin_index(value)

        self.bins[index].append(item)
872365
public Key put(Transaction transaction, Entity entity) {
		return datastore.put(transaction, entity);
	}
204507
def prepend(self, key, value, cas=0, format=None,
                persist_to=0, replicate_to=0):
        
        return _Base.prepend(self, key, value, cas=cas, format=format,
                             persist_to=persist_to, replicate_to=replicate_to)
955833
def insert(key, value):
    
    # Pickle the value.
    value = pickle.dumps(value, protocol=constants.PICKLE_PROTOCOL)
    # Store the value as binary data in a document.
    doc = {
        KEY_FIELD: key,
        VALUE_FIELD: Binary(value)
    }
    # Pickle and store the value with its key. If the key already exists, we
    # don't insert (since the key is a unique index), and we don't care.
    try:
        return collection.insert(doc)
    except pymongo.errors.DuplicateKeyError:
        return None
566950
def put(self, key, value, overwrite=True):
        
        self._get_table()
        s = self.to_string(value)
        log.debug("Storing in key '%s' the object: '%s'" % (key, s))
        self.table.put_item(
            data={
                'key': key,
                'value': s,
            },
            overwrite=overwrite
        )
1270337
function(id, key, value) {
      if(!memStore[id]) {
        memStore[id] = {};
      }

      if(typeof key === 'string' && typeof value !== 'undefined') {
        memStore[id][key] = value;
        return memStore[id][key];
      } else {
        throw new Error('invalid data type or missing value');
        return false;
      }
    }
1095931
def set(self, key, value):
        """"""
        self.store[key]=value
        return self.store
862911
def insert(self, key, column_parent, column, consistency_level):
    
    self._seqid += 1
    d = self._reqs[self._seqid] = defer.Deferred()
    self.send_insert(key, column_parent, column, consistency_level)
    return d