Updates type of specified key

@param key  Key
@param type SQL Type
@return this instance of QueryParameters
199159
public QueryParameters updateType(String key, Integer type) {
        this.types.put(processKey(key), type);

        return this;
    }
86080
public static void addNewMapping(final Class<?> type, final String property, final String mapping) {
        allowedColmns.computeIfAbsent(type, k -> new HashMap<>());
        allowedColmns.get(type).put(property, mapping);
    }
782183
@SuppressWarnings("unchecked")
	@Override
	public int update(final Object entity) {
		@SuppressWarnings("rawtypes")
		EntityHandler handler = this.getEntityHandler();
		if (!handler.getEntityType().isInstance(entity)) {
			throw new IllegalArgumentException("Entity type not supported");
		}

		try {
			Class<?> type = entity.getClass();
			TableMetadata metadata = handler.getMetadata(this.transactionManager, type);
			SqlContext context = handler.createUpdateContext(this, metadata, type, true);
			context.setSqlKind(SqlKind.UPDATE);
			handler.setUpdateParams(context, entity);
			int count = handler.doUpdate(this, context, entity);

			if (count == 0 && MappingUtils.getVersionMappingColumn(type).isPresent()) {
				throw new OptimisticLockException(context);
			}
			return count;
		} catch (SQLException e) {
			throw new EntitySqlRuntimeException(SqlKind.UPDATE, e);
		}
	}
60440
public <T> T get(String key, Class<T> type) {
        Object value = this.data.get(key);
        if (value != null && type.isAssignableFrom(value.getClass())) {
            return (T) value;
        }
        return null;
    }
488962
public <TYPE> TYPE get(String key, Class<TYPE> type) {
		return cache.get(key, type);
	}
879369
public String type(Object key) {
		Jedis jedis = getJedis();
		try {
			return jedis.type(keyToBytes(key));
		}
		finally {close(jedis);}
	}
711343
public ServiceInstanceQuery getContainQueryCriterion(String key){
        QueryCriterion c = new ContainQueryCriterion(key);
        addQueryCriterion(c);
        return this;
    }
1314573
public MapUpdate removeMap(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.MAP, k));
        return this;
    }
569284
public static QueryParameters updateTypesByName(QueryParameters original, QueryParameters source) {
        QueryParameters updatedParams = new QueryParameters(original);

        if (source != null) {
            for (String sourceKey : source.keySet()) {
                if (updatedParams.containsKey(sourceKey) == true) {
                    updatedParams.updateType(sourceKey, source.getType(sourceKey));
                }
            }
        }

        return updatedParams;
    }
844607
public QueryResults<Key> newKeyQuery(String kind) {
    // [START newKeyQuery]
    Query<Key> query = Query.newKeyQueryBuilder().setKind(kind).build();
    QueryResults<Key> results = datastore.run(query);
    // Use results
    // [END newKeyQuery]
    return results;
  }
479975
public List<T> query(String query, QueryType type)
    {
        switch (type)
        {
        case JPQL:
            return query(query);

        case NATIVE:
            return nativeQuery(query);

        default:
            throw new KunderaException("invalid query type");
        }
    }
651715
public QueryParameters updateDirection(String key, Direction direction) {
        this.direction.put(processKey(key), direction);

        return this;
    }
1074022
@Override
    public void setTypeMap(Map<String, Class<?>> arg0) throws SQLException {
        internalConn.setTypeMap(arg0);
    }
686164
public Request query(String key, Object value) {
        this.query.put(key, value);
        return this;
    }
555808
public int insertOrUpdate(Connection conn, Entity record, String... keys) throws SQLException {
		final Entity where = record.filter(keys);
		if(MapUtil.isNotEmpty(where) && count(conn, where) > 0) {
			return update(conn, record, where);
		}else {
			return insert(conn, record);
		}
	}
848903
public void removeTypeParam(String key) {

        List<String> selectedTypes = m_searchObject.getTypes();
        if (selectedTypes.contains(key)) {
            m_handler.onClearTypes(Collections.singletonList(key));
            selectedTypes.remove(key);
            updateResultsTab(false);
            ValueChangeEvent.fire(this, m_searchObject);
        }
    }
1084557
public final void updateKey(String key) throws IOException {
    Objects.requireNonNull(key, "old key required");
    if (index.containsKey(key)) {
      MtasSolrStatus status = index.get(key);
      index.remove(key);
      if (!index.containsKey(status.key())) {
        index.put(status.key(), status);
      } else {
        throw new IOException("key already exists");
      }
    }
  }