As of bash 3.2.9-10, bash no longer executes DOS formatted scripts as detailed in this announcement. I understand the reasoning for this is that:
To get around this restriction I did what was recommended in this bug report, i.e. I created a Windows user environment variable named “SHELLOPTS” with the value “igncr”.
After installing Cygwin when I tried to start the shell from a Windows command prompt by entering the “sh” command a window would pop up with this error.
The procedure entry point rl_getenv_hook could not be located in the dynamic link library cygreadline6.dll.
After seeing this error I would have to manually kill the sh process using the Windows Task Manager.
There was a thread about this on the Cygwin mailing list. I did what was suggested and discovered that bin/sh.exe and bin/bash.exe were exactly the same. Yet for some reason when I ran bash from the Windows command prompt I did not get this error.
I then tried rerunning the Cygwin installer. Even though nothing was installed that seemed to solve the problem, i.e. I was able to run sh from the Windows command prompt. This was possibly because the bash postinstall script was run correctly.
Update: After reboot I am experiencing the same problem again. Aargh! 🙁
Recently I upgraded my Java SDK from 1.5.0_08 to 1.5.0_11 to resolve a long path name issue for compiled classes. After doing this I updated the following ATG configuration files to reflect this change.
ATG allows one to use your own Java class data types for the properties of repository items. This is called User-Defined Property Types.
While working with these user-defined property types I learned a few things that are not explicitly documented.
atg.repository.FilePropertyDescriptor is supplied in the installation and it’s a good example for creating your own user-defined property type.
<property name="contentFile" property-type="atg.repository.FilePropertyDescriptor">
<attribute name="pathNameProperty" value="contentFileName"/>
</property>setValue() method. Continuing with the above example:
public void setValue(String pAttributeName, Object pValue) {
super.setValue(pAttributeName, pValue);
if (pValue == null || pAttributeName == null) return;
if (pAttributeName.equalsIgnoreCase(PATH_NAME_PROPERTY))
mPathNameProperty = pValue.toString();
if (pAttributeName.equalsIgnoreCase(PATH_PREFIX))
mPathPrefix = pValue.toString();
}
<property name="contentFile" data-type="string" property-type="atg.repository.FilePropertyDescriptor">
<attribute name="pathNameProperty" value="contentFileName"/>
</property> public java.lang.Object getPropertyValue(RepositoryItemImpl pItem, java.lang.Object pValue)
The first argument is the instance of the repository item whose property you are defining.
The second argument would be better named pCachedPropertyValue because it is the cached property value. If it is null then that means there is no cached value. If it is not null that means that in a previous call setPropertyValueInCache(this, yourvalue) was called. Unfortunately this cached value is not that useful because since only one instance of your user-defined property type is ever created, the cached value will be a global value.
This cached value is cleared when invalidateCaches is called on the repository item.
Here is what ATG support said about caching with User-Defined Property Types.
I think user defined properties will not be cached so that will cause your code to be
called several times. If you require some caching you would properly have to
implement it in the code of the user-defined property.As a user defined property could return data from any external source that might get
updated independently of the ATG application we can not really make a decision on
what should be cached and what should be retrieved anew every single time.Kind regards,
Olaf Doemer
A JavaBeans is simply a Java class with a set of properties, each property which has a getter and/or a setter. For example if the Java class has a name property it could be defined like this.
public class Foo {
private String mName;
public String getName() { return mName; }
public void setName(String pName) { mName = pName; }
}
Typically one accesses the property by directly calling its getter and/or setter. But sometimes you may not know the name of the property in advance but still might want to access the getter and/or setter. To do this one can use Java’s beans and reflection packages.
Here is an example of how one would read the value of a property of a JavaBean. Note that the property name should not be capitalized.
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
public Object getProperty(MyBean myBean, String propertyName) {
// get descriptor of property
PropertyDescriptor descriptor = new PropertyDescriptor(propertyName, myBean.getClass());
// invoke read method on property of myBean
Method readMethod = descriptor.getReadMethod();
return readMethod.invoke(memberSavingsProfile, (Object []) null);
}
Note that if your property only has a getter then you would create the PropertyDescriptor like this.
// get descriptor of property that only has a getter String readMethodName = "get" + org.apache.commons.lang.StringUtils.capitalize(propertyName); String writeMethodName = null; PropertyDescriptor descriptor = new PropertyDescriptor(propertyName, myBean.getClass(), readMethodName, writeMethodName);
Accessing the class from a static method which the class owns is a bit tricky. From a non-static method accessing the class is as simple as doing this.
// get stack trace
StackTraceElement[] stackTrace = new Throwable().getStackTrace();
// get the class name at the top level of the stack trace
StackTraceElement stackTraceTopLevelElem = stackTrace[0];
String thisClassName = stackTraceTopLevelElem.getClassName();
// get the class using the class loader
Class thisClass;
try {
thisClass = Class.forName(thisClassName);
} catch (ClassNotFoundException exc) {
// this should never happen
}
The other way is to use Java’s SecurityManager class as described in this article. This way seems preferable because it is not as costly as creating an exception as done in the other way.
Here is some sample code using the SecurityManager. Note that we need to use an inner class because the getClassContext() method is protected.
public static void main(String[] args) {
Class clazz = new ClassGetter().getClazz();
}
// inner class is necessary since getClassContext is protected
private static class ClassGetter extends SecurityManager {
protected ClassGetter() {
// do nothing
}
protected Class getClazz() {
Class [] classes = getClassContext();
Class clazz = classes[1];
return clazz;
}
}
Sometimes you might stumble upon this confusing exception.
org.hibernate.HibernateException: Found two representations of same collection: com.betweengo.Foos
This could have happened because after clearing a Hibernate session (session.clear()) you updated a property that contains a collection. I found just making sure to clear the session once seemed to fix the problem but that may not be a suitable solution in more complex situations.
More information about this problem can be found at http://forum.hibernate.org/viewtopic.php?p=2231400.
Oracle SQL queries can throw exceptions. For example in this query f there is no data then Oracle will throw a NO_DATA_FOUND exception.
SELECT status_date INTO v_status_date FROM member WHERE member_id = p_member_id_in;
ORA-01403: no data found
If this query is part of a stored procedure and is called from Hibernate you will get this uninformative exception.
org.hibernate.exception.DataException: could not execute query
Oracle SQL, like many languages, has a try catch construct. In this example you could do the following.
BEGIN
SELECT status_date INTO v_status_date FROM member WHERE member_id = p_member_id_in;
EXCEPTION
WHEN NO_DATA_FOUND THEN
v_status_date := NULL;
END;
Calling an Oracle function is quite simple. For example
SELECT package.register(1, "Frank", "Kim") FROM dual;
However calling Oracle stored procedures is a bit more tricky, especially if the Oracle stored procedure has output parameters. Here is an example of how to call an Oracle stored procedure that has three input parameters and two output parameters.
DECLARE p_credit_status_out INTEGER;
p_school_status_out INTEGER;
BEGIN
package.get_status(1, "Frank", "Kim", p_credit_status_out, p_school_status_out);
END;
/
Creation
CREATE TRIGGER trig_frank
BEFORE INSERT ON table_frank
FOR EACH ROW
BEGIN
SELECT seq_frank.nextval
INTO :new.id
FROM dual;
END;
.
RUN;
References