Updates the JDBC driver class names.<p>
Needs to be executed before any database access.<p>
434721
public void updateDBDriverClassName() {

        Set<String> keys = new HashSet<String>();
        // replace MySQL JDBC driver class name
        CmsParameterConfiguration properties = getProperties();
        for (Entry<String, String> propertyEntry : properties.entrySet()) {
            if (MYSQL_DRIVER_CLASS_OLD.equals(propertyEntry.getValue())) {
                keys.add(propertyEntry.getKey());
            }
        }
        for (String key : keys) {
            properties.put(key, MYSQL_DRIVER_CLASS_NEW);
        }
        if (!keys.isEmpty()) {
            saveProperties(properties, CmsSystemInfo.FILE_PROPERTIES, false, keys);
        }
    }
669403
private void updateOtherClientRenamed() throws IOException
    {
        final byte cid = in.readByte();
        final String cname = readString();
        for (final ConnectionListener listener : listeners)
        {
            listener.notifyClientNameChanged(Byte.valueOf(cid), cname);
        }
    }
1302361
protected void update(List<TableInfo> tableInfos)
    {
        try
        {
            createOrUpdateKeyspace(tableInfos);
        }
        catch (Exception ex)
        {
            log.error("Error occurred while creating {}, Caused by: .", databaseName, ex);
            throw new SchemaGenerationException(ex);
        }
    }
345656
@Override
	public void execute(SQLiteDatabase database, int previuosVersion, int currentVersion) {
		List<String> executionList=null;
	
		if (inputStream==null) {
			File f = new File(schemaDefinitionFile);
			executionList = SQLiteUpdateTaskHelper.readSQLFromFile(schemaDefinitionFile);
			Logger.info("Load DDL from " + f.getAbsolutePath());
		} else {
			executionList = SQLiteUpdateTaskHelper.readSQLFromFile(inputStream);
			Logger.info("Load DDL from stream");
		}
		
		for (String item : executionList) {
			Logger.info(item);
			database.execSQL(item);
		}

	}
576394
private void updateClassForTab(int index) {

        Widget widget = m_tabbedPanel.getWidget(index);

        String propertyTabStyle = STYLE_PROPERTIES_TAB_ACTIVE;
        if (widget == m_propertiesTab) {
            CmsImagePreviewDialog.this.addStyleName(propertyTabStyle);
        } else {
            CmsImagePreviewDialog.this.removeStyleName(propertyTabStyle);
        }
    }
110377
public void addUpdate(final Update update) {
        if (updates == null) {
            updates = new ArrayList<Update>();
        }
        updates.add(update);
    }
1323142
private void init()
    {
        jdbcProperties = new Properties();
        dbcpProperties = new Properties();
        setFetchSize(0);
        this.setTestOnBorrow(true);
        this.setTestOnReturn(false);
        this.setTestWhileIdle(false);
        this.setLogAbandoned(false);
        this.setRemoveAbandoned(false);
    }
786568
@Override
	public synchronized void updateHistoryIds(int alertId, 
            int historyId, int sourceHistoryId) throws DatabaseException {
        
        try {
			psUpdateHistoryIds.setInt(1, historyId);
			psUpdateHistoryIds.setInt(2, sourceHistoryId);
			psUpdateHistoryIds.setInt(3, alertId);
			psUpdateHistoryIds.executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		}
    }
67542
protected void updateClassnames(HashMap<String,HashSet<String>> cache, String superclass, HashSet<String> names) {
    if (!cache.containsKey(superclass))
      cache.put(superclass, names);
    else
      cache.get(superclass).addAll(names);
  }
739350
public void setConnectionNameList(java.util.Collection<String> connectionNameList) {
        if (connectionNameList == null) {
            this.connectionNameList = null;
            return;
        }

        this.connectionNameList = new java.util.ArrayList<String>(connectionNameList);
    }
755214
public Script updateName(int id, String name) throws Exception {
        PreparedStatement statement = null;

        try (Connection sqlConnection = SQLService.getInstance().getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_SCRIPT +
                    " SET " + Constants.SCRIPT_NAME + " = ? " +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, name);
            statement.setInt(2, id);
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }

        return this.getScript(id);
    }
488950
@Override
	public synchronized void update(long sessionId, String sessionName) throws DatabaseException {
        try {
			psUpdate.setLong(2, sessionId);
			psUpdate.setString(1, sessionName);
			psUpdate.executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		}
    }
1314993
public void update(final Collection<T> values) throws DataAccessException {
        jdbcTemplate.execute(new ConnectionCallback<Object>() {
            @Override
            public Object doInConnection(Connection connection) throws SQLException, DataAccessException {
                crud.update(connection, values);
                return null;
            }
        });
    }
1022007
@Override
	public void updateContext() {

		// Find the path to update
		String newInstancePath = "/" + this.instancePath.replaceFirst( "/[^/]+$", this.newInstanceName );

		Map<String,String> copy = new HashMap<>( this.context.instancePathToComponentName );
		for( Map.Entry<String,String> entry : copy.entrySet()) {
			if( ! entry.getKey().startsWith( this.instancePath + "/" )
					&& ! entry.getKey().equals( this.instancePath ))
				continue;

			String updatedPath = entry.getKey().replace( this.instancePath, newInstancePath );
			this.context.instancePathToComponentName.remove( entry.getKey());
			this.context.instancePathToComponentName.put( updatedPath, entry.getValue());
		}
	}
550599
public void update() {
        embeddedAn = (Embedded) getAnnotation(Embedded.class);
        entityAn = (Entity) getFirstAnnotation(Entity.class);
        // polymorphicAn = (Polymorphic) getAnnotation(Polymorphic.class);
        final List<MappedField> fields = getFieldsAnnotatedWith(Id.class);
        if (fields != null && !fields.isEmpty()) {
            idField = fields.get(0).getField();
        }
    }
1180248
private void pushJDBCSupport(CodeBuilder b) {
        b.loadThis();
        b.loadField(StorableGenerator.SUPPORT_FIELD_NAME, TypeDesc.forClass(TriggerSupport.class));
        b.checkCast(TypeDesc.forClass(JDBCSupport.class));
    }
1254867
@Override
    protected void update(List<TableInfo> tableInfos)
    {
        StatementResult result = null;
        String statement = null;
        for (TableInfo tableInfo : tableInfos)
        {
            try
            {
                Table table = tableAPI.getTable(tableInfo.getTableName());
                if (table == null)
                {
                    statement = buildCreateDDLQuery(tableInfo);
                    result = tableAPI.executeSync(statement);
                    if (!result.isSuccessful())
                    {
                        throw new SchemaGenerationException("Unable to CREATE TABLE " + tableInfo.getTableName());
                    }
                }
                else
                {
                    List<ColumnInfo> columnInfos = tableInfo.getColumnMetadatas();
                    Map<String, String> newColumns = new HashMap<String, String>();
                    for (ColumnInfo column : columnInfos)
                    {
                        if (table.getField(column.getColumnName()) == null)
                        {
                            newColumns.put(column.getColumnName(), column.getType().getSimpleName());
                        }
                    }

                    List<EmbeddedColumnInfo> embeddedColumnInfos = tableInfo.getEmbeddedColumnMetadatas();
                    for (EmbeddedColumnInfo embeddedColumnInfo : embeddedColumnInfos)
                    {
                        for (ColumnInfo column : embeddedColumnInfo.getColumns())
                        {
                            if (table.getField(column.getColumnName()) == null)
                            {
                                newColumns.put(column.getColumnName(), column.getType().getSimpleName());
                            }
                        }
                    }
                    if (!newColumns.isEmpty())
                    {
                        statement = buildAlterDDLQuery(tableInfo, newColumns);
                        result = tableAPI.executeSync(statement);

                        if (!result.isSuccessful())
                        {
                            throw new SchemaGenerationException("Unable to ALTER TABLE " + tableInfo.getTableName());
                        }
                    }
                }
                createIndexOnTable(tableInfo);
            }
            catch (IllegalArgumentException e)
            {
                logger.error("Invalid Statement. Caused By: ", e);
                throw new SchemaGenerationException(e, "Invalid Statement. Caused By: ");
            }
            catch (FaultException e)
            {
                logger.error("Statement couldn't be executed. Caused By: ", e);
                throw new SchemaGenerationException(e, "Statement couldn't be executed. Caused By: ");
            }
        }
    }