Updates a path table value for column columnName

@param columnName name of the column to update
@param newData new content to set
@param path_id ID of the path to update
333322
public static void updatePathTable(String columnName, Object newData, int path_id) {
        PreparedStatement statement = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + columnName + " = ?" +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setObject(1, newData);
            statement.setInt(2, path_id);
            statement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
623901
public void setContentType(int pathId, String contentType) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + Constants.PATH_PROFILE_CONTENT_TYPE + " = ? " +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, contentType);
            statement.setInt(2, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
798229
private ItemData updatePathIfNeeded(ItemData data) throws IllegalPathException
   {
      if (data == null || changesLog.getAllPathsChanged() == null)
         return data;
      List<ItemState> states = changesLog.getAllPathsChanged();
      for (int i = 0, length = states.size(); i < length; i++)
      {
         ItemState state = states.get(i);
         if (data.getQPath().isDescendantOf(state.getOldPath()))
         {
            data = updatePath(state.getOldPath(), state.getData().getQPath(), data);
         }
      }
      return data;
   }
173214
public static SyncMapItemUpdater updater(final String pathServiceSid, 
                                             final String pathMapSid, 
                                             final String pathKey, 
                                             final Map<String, Object> data) {
        return new SyncMapItemUpdater(pathServiceSid, pathMapSid, pathKey, data);
    }
53674
public static SyncListItemUpdater updater(final String pathServiceSid, 
                                              final String pathListSid, 
                                              final Integer pathIndex) {
        return new SyncListItemUpdater(pathServiceSid, pathListSid, pathIndex);
    }
977521
public void updatePathOrder(int profileId, int[] pathOrder) {
        for (int i = 0; i < pathOrder.length; i++) {
            EditService.updatePathTable(Constants.PATH_PROFILE_PATH_ORDER, (i + 1), pathOrder[i]);
        }
    }
667295
public void update(float newData) {
        float data = history[0]*decay + newData*(1-decay);

        float[] r = new float[Math.min(history.length+1,historySize)];
        System.arraycopy(history,0,r,1,Math.min(history.length,r.length-1));
        r[0] = data;
        history = r;
    }
221804
public static VariableUpdater updater(final String pathServiceSid, 
                                          final String pathEnvironmentSid, 
                                          final String pathSid) {
        return new VariableUpdater(pathServiceSid, pathEnvironmentSid, pathSid);
    }
287324
public void setHostHeader(String newHost, int id) {
        PreparedStatement statement = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_SERVERS +
                    " SET " + Constants.SERVER_REDIRECT_HOST_HEADER + " = ?" +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, newHost);
            statement.setInt(2, id);
            statement.executeUpdate();
            statement.close();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
149090
public int execute(DatabaseConnection databaseConnection, T data, ID newId, ObjectCache objectCache)
			throws SQLException {
		try {
			// the arguments are the new-id and old-id
			Object[] args = new Object[] { convertIdToFieldObject(newId), extractIdToFieldObject(data) };
			int rowC = databaseConnection.update(statement, args, argFieldTypes);
			if (rowC > 0) {
				if (objectCache != null) {
					Object oldId = idField.extractJavaFieldValue(data);
					T obj = objectCache.updateId(clazz, oldId, newId);
					if (obj != null && obj != data) {
						// if our cached value is not the data that will be updated then we need to update it specially
						idField.assignField(connectionSource, obj, newId, false, objectCache);
					}
				}
				// adjust the object to assign the new id
				idField.assignField(connectionSource, data, newId, false, objectCache);
			}
			logger.debug("updating-id with statement '{}' and {} args, changed {} rows", statement, args.length, rowC);
			if (args.length > 0) {
				// need to do the cast otherwise we only print the first object in args
				logger.trace("updating-id arguments: {}", (Object) args);
			}
			return rowC;
		} catch (SQLException e) {
			throw SqlExceptionUtil.create("Unable to run update-id stmt on object " + data + ": " + statement, e);
		}
	}
760053
public void update(Object[] newValues, boolean updateOutOnly) {
        AssertUtils.assertNotNull(newValues);

        if (newValues.length != this.values.size()) {
            throw new IllegalArgumentException(ERROR_INCORRECT_LENGTH);
        }

        this.assertIncorrectOrder();

        String parameterName = null;
        for (int i = 0; i < newValues.length; i++) {
            parameterName = this.getNameByPosition(i);

            if (updateOutOnly == false || isOutParameter(parameterName) == true) {
                parameterName = this.getNameByPosition(i);

                this.updateValue(parameterName, newValues[i]);
            }
        }
    }
143690
function addCol($col_data, $col_id = 0, $row_id = 0) {
        foreach ($col_data as $col_cell) {
            $this->_data[$row_id++][$col_id] = $col_cell;
        }

        $this->_updateRowsCols();
        $this->_max_cols = max($this->_max_cols, $col_id + 1);
    }
502819
public void setBodyFilter(int pathId, String bodyFilter) {
        PreparedStatement statement = null;
        try (Connection sqlConnection = sqlService.getConnection()) {
            statement = sqlConnection.prepareStatement(
                "UPDATE " + Constants.DB_TABLE_PATH +
                    " SET " + Constants.PATH_PROFILE_BODY_FILTER + " = ? " +
                    " WHERE " + Constants.GENERIC_ID + " = ?"
            );
            statement.setString(1, bodyFilter);
            statement.setInt(2, pathId);
            statement.executeUpdate();
            statement.close();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }
    }
772733
public static FunctionUpdater updater(final String pathServiceSid, 
                                          final String pathSid, 
                                          final String friendlyName) {
        return new FunctionUpdater(pathServiceSid, pathSid, friendlyName);
    }
242372
public void updateNodeForId(final CmsUUID id) {

        final List<CmsSitemapTreeNode> nodes = Lists.newArrayList();
        CmsVaadinUtils.visitDescendants(m_currentRootNode, new Predicate<Component>() {

            public boolean apply(Component input) {

                if (input instanceof CmsSitemapTreeNode) {
                    CmsSitemapTreeNode node = (CmsSitemapTreeNode)input;
                    CmsSitemapTreeNodeData data = (CmsSitemapTreeNodeData)node.getData();
                    if (data.getResource().getStructureId().equals(id)) {
                        nodes.add(node);
                        return false;
                    }
                }
                return true;
            }
        });
        if (nodes.size() == 1) {
            updateNode(nodes.get(0));
        }

    }
298488
def new_leaves(self, column_name):
        
        column_name = unnest_path(column_name)
        columns = self.columns
        all_paths = self.snowflake.sorted_query_paths

        output = {}
        for c in columns:
            if c.name == "_id" and column_name != "_id":
                continue
            if c.jx_type in OBJECTS:
                continue
            if c.cardinality == 0:
                continue
            for path in all_paths:
                if not startswith_field(unnest_path(relative_field(c.name, path)), column_name):
                    continue
                existing = output.get(path)
                if not existing:
                    output[path] = [c]
                    continue
                if len(path) > len(c.nested_path[0]):
                    continue
                if any("." + t + "." in c.es_column for t in (STRING_TYPE, NUMBER_TYPE, BOOLEAN_TYPE)):
                    # ELASTICSEARCH field TYPES ARE NOT ALLOWED
                    continue
                # ONLY THE DEEPEST COLUMN WILL BE CHOSEN
                output[path].append(c)
        return set(output.values())
1124474
public Dataset updateDataset(String datasetName, String newDescription) {
    // [START bigquery_update_dataset_description]
    Dataset oldDataset = bigquery.getDataset(datasetName);
    DatasetInfo datasetInfo = oldDataset.toBuilder().setDescription(newDescription).build();
    Dataset newDataset = bigquery.update(datasetInfo);
    // [END bigquery_update_dataset_description]
    return newDataset;
  }