Store the modification. `value` should be dumped in DB compatible format.
963581
def modifie(self, key: str, value: Any) -> None:
        """"""
        if key in self.FIELDS_OPTIONS:
            self.modifie_options(key, value)
        else:
            self.modifications[key] = value
241727
public void store(Object key, Object value) {
        getJdbcTemplate().update(getMergeSql(),
                                 new BeanPropertySqlParameterSource(value));
    }
927380
def store(key, value, mode = nil)
      if mode == :dup
        if value.is_a? Array
          Utilities.temp_list(value.size) do |list|
            list.push(*value) { |string| cast_value_in(string) }
            try(:putdup3, cast_key_in(key), list.pointer)
          end
        else
          try(:putdup, cast_key_in(key), cast_value_in(value))
        end
        value
      else
        super
      end
    end
7489
private void updateValue(Value value) {
    while (true) {
      Value current = currentValue.get();
      if (value.isNewerThan(current)) {
        if (currentValue.compareAndSet(current, value)) {
          if (current == null || !Objects.equals(current.value(), value.value())) {
            eventListeners.forEach(listener -> listener.event(new ValueDelegateEvent<>(ValueDelegateEvent.Type.UPDATE, decode(value.value()))));
          }
          break;
        }
      } else {
        break;
      }
    }
  }
640746
def append(self, value):
        """"""
        self.database.run_script(
            'array_append',
            keys=[self.key],
            args=[value])
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
39904
def store(resolved_path, value)
      result = if result_type == RESULT_TYPE_PATH
                 as_path(resolved_path)
               else
                 value
               end
      Enumpath.log('New Result') { { result: result } }
      push(result)
    end
1315064
def append(self, value):
    """"""
    self._values.append(self._type_checker.CheckValue(value))
    if not self._message_listener.dirty:
      self._message_listener.Modified()
104073
def put_value(self, value, timeout=None):
        """"""
        self._context.put(self._data.path + ["value"], value, timeout=timeout)
731323
def save_output_value(name, value)
      set_field(CONTEXT_OUTPUTS_META, {}) if get_field(CONTEXT_OUTPUTS_META).nil?
      get_field(CONTEXT_OUTPUTS_META)[name] = value
    end
618871
public void put(Double value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			this.compiledStatement.bindDouble(compiledStatementBindIndex++, value);
		}
	}
693800
def value_to_db(self, value):
        
        assert isinstance(value, six.integer_types)
        return str(value).encode("utf_8")
690639
public void put(String key, Integer value) {
		if (this.compiledStatement != null) {
			if (value == null) {
				this.compiledStatement.bindNull(compiledStatementBindIndex++);
			} else {
				compiledStatement.bindLong(compiledStatementBindIndex++, (int) value);
			}
		} else if (values != null) {
			values.put(key, value);
			return;
		}

		names.add(key);
		// values.put(key, value);
		args.add(value);
		valueType.add(ParamType.INTEGER);
	}
475048
def put(key, value)
      if key == ''
        @object_types[:root] = [:root]
        @store[:root] = value
      else
        @notfound.delete(key.to_sym)
        (@object_types[value.type] ||= []) << key.to_s
        if @store[key.to_sym]
          @object_types[@store[key.to_sym].type].delete(key.to_s)
        end
        @store[key.to_sym] = value
      end
    end
285552
public void put(Boolean value) {
		if (value == null) {
			this.compiledStatement.bindNull(compiledStatementBindIndex++);
		} else {
			this.compiledStatement.bindLong(compiledStatementBindIndex++, (value == true ? 1 : 0));
		}
	}
149332
def store(self, name, value, atype, new_name=None, multiplier=None, allowed_values=None):
        '''  '''
        if value is not None:
            _bad_type = (not isinstance(value, atype))
            if not _bad_type:
                # special case
                _bad_type = (isinstance(value, bool) and atype == int)

            if _bad_type:
                # could be a special value
                if allowed_values and value in allowed_values:
                    allowed_values = None
                else:
                    raise ValueError("%s should be value of type (%s)" % (name, atype.__name__))

            if allowed_values:
                if isinstance(value, str):
                    if value not in allowed_values:
                        raise ValueError("%s can be %s" % (name, allowed_values))
                elif isinstance(value, int):
                    if isinstance(allowed_values[0], int):
                        if value < allowed_values[0]:
                            raise ValueError("%s must be >= %d" % (name, allowed_values[0]))

            _val = value if not multiplier else (multiplier * value)
            _name = name if not new_name else new_name
            self._dict[_name] = _val
930797
def save_var(name, value):
    
    connection = _State.connection()
    _State.reflect_metadata()

    vars_table = sqlalchemy.Table(
        _State.vars_table_name, _State.metadata,
        sqlalchemy.Column('name', sqlalchemy.types.Text, primary_key=True),
        sqlalchemy.Column('value_blob', sqlalchemy.types.LargeBinary),
        sqlalchemy.Column('type', sqlalchemy.types.Text),
        keep_existing=True
    )

    vars_table.create(bind=connection, checkfirst=True)

    column_type = get_column_type(value)

    if column_type == sqlalchemy.types.LargeBinary:
        value_blob = value
    else:
        value_blob = unicode(value).encode('utf-8')

    values = dict(name=name,
                  value_blob=value_blob,
                  # value_blob=Blob(value),
                  type=column_type.__visit_name__.lower())

    vars_table.insert(prefixes=['OR REPLACE']).values(**values).execute()