*/
    public OptionalEntity<RelatedContent> getRelatedContent(final String id) {
        return relatedContentBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a related content entity.
     * After storing, updates the related content helper to refresh the cache.
     *
     * @param relatedContent the RelatedContent entity to store
     */
    public void store(final RelatedContent relatedContent) {

}

// Close - closes underneath connections to MySQL database.
func (target *MySQLTarget) Close() error {
	close(target.quitCh)
	if target.updateStmt != nil {
		// FIXME: log returned error. ignore time being.
		_ = target.updateStmt.Close()
	}

	if target.deleteStmt != nil {
		// FIXME: log returned error. ignore time being.
		_ = target.deleteStmt.Close()
	}

  public void decrement() {
    add(-1L);
  }

  /**
   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in
   * the absence of concurrent updates returns an accurate result, but concurrent updates that occur
   * while the sum is being calculated might not be incorporated.
   *
   * @return the sum
   */
  @Override
  public long sum() {
    long sum = base;
    Cell[] as = cells;

        String checksums = toRepositoryChecksumPolicy(RepositoryPolicy.CHECKSUM_POLICY_WARN); // the default
        String updates = RepositoryPolicy.UPDATE_POLICY_DAILY;

        if (policy != null) {
            enabled = policy.isEnabled();
            if (policy.getUpdatePolicy() != null) {
                updates = policy.getUpdatePolicy();
            }
            if (policy.getChecksumPolicy() != null) {

     *
     * @param accessResult the access result to store
     */
    void store(RESULT accessResult);

    /**
     * Updates the given access result.
     *
     * @param accessResult the access result to update
     */
    void update(RESULT accessResult);

    /**
     * Updates the given list of access results.
     *
     * @param accessResult the list of access results to update
     */

#
# That will prepare the files and create the commit.
#
# To review such a commit (as the reviewer), use:
#
#	git codereview change NNNNNN   # CL number
#	cd lib/time
#	./update.bash
#
# If it prints "No updates needed.", then the generated files
# in the CL match the update.bash in the CL.

# Versions to use.
CODE=2025c
DATA=2025c

set -e

cd $(dirname $0)
rm -rf work
mkdir work

        msgs.add("* as @threadSafe to support parallel building.                  *");
        msgs.add("* While this /may/ work fine, please look for plugin updates    *");
        msgs.add("* and/or request plugins be made thread-safe.                   *");
        msgs.add("* If reporting an issue, report it against the plugin in        *");

	}

	DB.Model(&product).Select("code", "price").Updates(map[string]interface{}{"code": "L1212"})

	if product.Price != 150 || product.Code != "L1212" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	// Code not changed, price should not change
	DB.Model(&product).Updates(map[string]interface{}{"Name": "Product New"})

        if (log.isTraceEnabled()) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);
            log.trace(Hexdump.toHexString(input, offset, Math.min(len, 256)));
        }
        if (len == 0) {
            return; /* CRITICAL */
        }
        this.digest.update(input, offset, len);
        this.updates++;
    }

    /**
     * Finalize and return the calculated message digest

					return err
				}
				return base.Updates(fkNil).Error
			})
		case clause.OpUnlink:
			return base.Updates(fkNil).Error
		case clause.OpUpdate:
			return assocDB.Where("? IN (?)", primaryColumns, base.Select(ownerFKNames)).Updates(setMap).Error
		}
	case schema.Many2Many:
		joinModel := reflect.New(rel.JoinTable.ModelType).Interface()