Author: struberg
Date: Sun Jan 18 14:30:44 2015
New Revision: 1652761
URL: http://svn.apache.org/r1652761
Log:
OPENJPA-2558 implement BooleanRepresentation which can be switched via config
Each DBDictionary has it's own default BooleanRepresentation but can easily get
changed by the user
e.g. via
<property name="openjpa.jdbc.DBDictionary"
value="(BitTypeName=CHAR(1),BooleanTypeName=CHAR(1),BooleanRepresentation=STRING_10)"/>
Added:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/BooleanRepresentation.java
openjpa/trunk/openjpa-jdbc/src/test/java/org/apache/openjpa/jdbc/sql/TestBooleanRepresentation.java
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionary.java
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionaryFactory.java
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/PostgresDictionary.java
openjpa/trunk/openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/sql/localizer.properties
openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_conf.xml
openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_dbsetup.xml
Added:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/BooleanRepresentation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/BooleanRepresentation.java?rev=1652761&view=auto
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/BooleanRepresentation.java
(added)
+++
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/BooleanRepresentation.java
Sun Jan 18 14:30:44 2015
@@ -0,0 +1,303 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.openjpa.jdbc.sql;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Arrays;
+
+import org.apache.openjpa.lib.util.Localizer;
+import org.apache.openjpa.util.UserException;
+
+/**
+ * <p>Defines how a {@code Boolean} or {@code boolean} value
+ * gets stored in the database by default.</p>
+ *
+ * <p>The {@link DBDictionary} defines a default representation for {@code
Boolean}
+ * and {@code boolean} fields in JPA entities. The {@link
org.apache.openjpa.jdbc.sql.OracleDictionary}
+ * for example uses a {@code NUMBER(1)} with the values {@code (int) 1} and
{@code (int) 0} by default.
+ * However, sometimes you like to use a different default representation for
Boolean values in your database.
+ * If your application likes to store boolean values in a {@code CHAR(1)}
field with {@code "T"} and
+ * {@code "F"} values then you might configure the {@link
org.apache.openjpa.jdbc.sql.DBDictionary}
+ * to use the {@link
org.apache.openjpa.jdbc.sql.BooleanRepresentation.BooleanRepresentations#STRING_TF}
+ * BooleanRepresentation:
+ * <pre>
+ * <property name="openjpa.jdbc.DBDictionary"
+ *
value="(BitTypeName=CHAR(1),BooleanTypeName=CHAR(1),BooleanRepresentation=STRING_10)"/>
+ * </pre>
+ *
+ * Please note that you still need to adopt the mapping separately by setting
the
+ * {@code BitTypeName} and/or {@code BooleanTypeName} (depending on your
database) to
+ * the desired type in the database.
+ * </p>
+ *
+ * <p>The following {@code BooleanRepresentation} configuration options are
possible:
+ * <ul>
+ * <li>One of the enum values of {@link
org.apache.openjpa.jdbc.sql.BooleanRepresentation.BooleanRepresentations}
+ * , e.g.:
+ * <pre>
+ * <property name="openjpa.jdbc.DBDictionary"
value="(BooleanRepresentation=STRING_YN)"/>
+ * </pre>
+ * </li>
+ * <li>
+ * Two slash ({@code '/'}) separated true/false value strings:
+ * <pre>
+ * <property name="openjpa.jdbc.DBDictionary"
value="(BooleanRepresentation=oui/non)"/>
+ * </pre>
+ * </li>
+ * <li>
+ * A fully qualified class name of your own {@link
org.apache.openjpa.jdbc.sql.BooleanRepresentation}
+ * implementation, e.g.:
+ * <pre>
+ * <property name="openjpa.jdbc.DBDictionary"
+ *
value="(BooleanRepresentation=com.mycompany.MyOwnBoolRepresentation)"/>
+ * </pre>
+ * </li>
+ * </ul>
+ *
+ * </p>
+ *
+ * <p>If a single column uses a different representation then they
+ * still can tweak this for those columns with the
+ * {@code org.apache.openjpa.persistence.ExternalValues} annotation.</p>
+ */
+public interface BooleanRepresentation {
+
+ /**
+ * Set the boolean value into the statement
+ * @param stmnt
+ * @param columnIndex
+ * @param val the boolean value to set
+ * @throws SQLException
+ */
+ public void setBoolean(PreparedStatement stmnt, int columnIndex, boolean
val) throws SQLException;
+
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException;
+
+
+ public static class Factory {
+ public static BooleanRepresentation valueOf(String
booleanRepresentationKey, ClassLoader cl) {
+ BooleanRepresentation booleanRepresentation = null;
+
+ // 1st step, try to lookup the BooleanRepresentation from the
default ones
+ try {
+ booleanRepresentation =
BooleanRepresentations.valueOf(booleanRepresentationKey);
+ }
+ catch (IllegalArgumentException iae) {
+ // nothing to do
+ }
+
+ if (booleanRepresentation == null &&
booleanRepresentationKey.contains("/")) {
+ // if the key contains a '/' then the first value is the key
for 'true', the 2nd value is for 'false'
+ String[] vals = booleanRepresentationKey.split("/");
+ if (vals.length == 2) {
+ booleanRepresentation = new
StringBooleanRepresentation(vals[0], vals[1]);
+ }
+ }
+ else {
+ // or do a class lookup for a custom BooleanRepresentation
+ try {
+ Class<? extends BooleanRepresentation>
booleanRepresentationClass
+ = (Class<? extends BooleanRepresentation>)
cl.loadClass(booleanRepresentationKey);
+ booleanRepresentation =
booleanRepresentationClass.newInstance();
+ }
+ catch (Exception e) {
+ // nothing to do
+ //X TODO probably log some error?
+ }
+ }
+
+
+ if (booleanRepresentation == null) {
+ Localizer _loc =
Localizer.forPackage(BooleanRepresentation.class);
+ throw new
UserException(_loc.get("unknown-booleanRepresentation",
+ new Object[]{booleanRepresentationKey,
+
Arrays.toString(BooleanRepresentation.BooleanRepresentations.values())}
+ ));
+
+ }
+ else {
+ //X TODO add logging about which one got picked up finally
+ }
+
+ return booleanRepresentation;
+ }
+ }
+
+ /**
+ * BooleanRepresentation which takes 2 strings for true and false
representations
+ * as constructor parameter;
+ */
+ public static class StringBooleanRepresentation implements
BooleanRepresentation {
+ private final String trueRepresentation;
+ private final String falseRepresentation;
+
+ public StringBooleanRepresentation(String trueRepresentation, String
falseRepresentation) {
+ this.trueRepresentation = trueRepresentation;
+ this.falseRepresentation = falseRepresentation;
+ }
+
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean val)
throws SQLException{
+ stmnt.setString(idx, val ? trueRepresentation :
falseRepresentation);
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return trueRepresentation.equals(rs.getString(columnIndex));
+ }
+
+ @Override
+ public String toString() {
+ return "StringBooleanRepresentation with the following values for
true and false: "
+ + trueRepresentation + " / " + falseRepresentation;
+ }
+ }
+
+ public enum BooleanRepresentations implements BooleanRepresentation {
+
+ /**
+ * Booleans are natively supported by this very database.
+ * The database column is e.g. a NUMBER(1)
+ * OpenJPA will use preparedStatement.setBoolean(..) for it
+ */
+ BOOLEAN {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException {
+ stmnt.setBoolean(idx, val);
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return rs.getBoolean(columnIndex);
+ }
+ },
+
+ /**
+ * Booleans are stored as numeric int 1 and int 0 values.
+ * The database column is e.g. a NUMBER(1)
+ * OpenJPA will use preparedStatement.setInt(..) for it
+ */
+ INT_10 {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setInt(idx, val ? 1 : 0);
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return rs.getInt(columnIndex) > 0;
+ }
+ },
+
+ /**
+ * Booleans are stored as String "1" for {@code true}
+ * and String "0" for {@code false}.
+ * The database column is e.g. a CHAR(1) or VARCHAR(1)
+ * OpenJPA will use preparedStatement.setString(..) for it
+ */
+ STRING_10 {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setString(idx, val ? "1" : "0");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "1".equals(rs.getString(columnIndex));
+ }
+ },
+
+ /**
+ * Booleans are stored as String "Y" for {@code true}
+ * and String "N" for {@code false}.
+ * The database column is e.g. a CHAR(1) or VARCHAR(1)
+ * OpenJPA will use preparedStatement.setString(..) for it
+ */
+ STRING_YN {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setString(idx, val ? "Y" : "N");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "Y".equals(rs.getString(columnIndex));
+ }
+ },
+
+ /**
+ * Booleans are stored as String "y" for {@code true}
+ * and String "n" for {@code false}.
+ * The database column is e.g. a CHAR(1) or VARCHAR(1)
+ * OpenJPA will use preparedStatement.setString(..) for it
+ */
+ STRING_YN_LOWERCASE {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setString(idx, val ? "y" : "n");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "y".equals(rs.getString(columnIndex));
+ }
+ },
+
+ /**
+ * Booleans are stored as String "T" for {@code true}
+ * and String "F" for {@code false}.
+ * The database column is e.g. a CHAR(1) or VARCHAR(1)
+ * OpenJPA will use preparedStatement.setString(..) for it
+ */
+ STRING_TF {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setString(idx, val ? "T" : "F");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "T".equals(rs.getString(columnIndex));
+ }
+
+ },
+
+ /**
+ * Booleans are stored as String "t" for {@code true}
+ * and String "f" for {@code false}.
+ * The database column is e.g. a CHAR(1) or VARCHAR(1)
+ * OpenJPA will use preparedStatement.setString(..) for it
+ */
+ STRING_TF_LOWERCASE {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean
val) throws SQLException{
+ stmnt.setString(idx, val ? "t" : "f");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "t".equals(rs.getString(columnIndex));
+ }
+ };
+
+ }
+
+}
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionary.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionary.java?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionary.java
(original)
+++
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionary.java
Sun Jan 18 14:30:44 2015
@@ -178,9 +178,9 @@ public class DBDictionary
private static final Localizer _loc =
Localizer.forPackage(DBDictionary.class);
// Database version info preferably set from Connection metadata
- private int major;
- private int minor;
-
+ private int major;
+ private int minor;
+
// schema data
public String platform = "Generic";
public String databaseProductName = "";
@@ -326,7 +326,14 @@ public class DBDictionary
*/
public enum DateMillisecondBehaviors { DROP, ROUND, RETAIN };
private DateMillisecondBehaviors dateMillisecondBehavior;
-
+
+ /**
+ * Defines how {@code Boolean} and {@code boolean} values get represented
+ * in OpenJPA. Default to {@link
org.apache.openjpa.jdbc.sql.BooleanRepresentation.BooleanRepresentations#INT_10}
+ * for backward compatibility.
+ */
+ protected BooleanRepresentation booleanRepresentation =
BooleanRepresentation.BooleanRepresentations.INT_10;
+
public int characterColumnSize = 255;
public String arrayTypeName = "ARRAY";
public String bigintTypeName = "BIGINT";
@@ -703,7 +710,7 @@ public class DBDictionary
*/
public boolean getBoolean(ResultSet rs, int column)
throws SQLException {
- return rs.getBoolean(column);
+ return booleanRepresentation.getBoolean(rs, column);
}
/**
@@ -1054,10 +1061,9 @@ public class DBDictionary
/**
* Set the given value as a parameter to the statement.
*/
- public void setBoolean(PreparedStatement stmnt, int idx, boolean val,
- Column col)
+ public void setBoolean(PreparedStatement stmnt, int idx, boolean val,
Column col)
throws SQLException {
- stmnt.setInt(idx, (val) ? 1 : 0);
+ booleanRepresentation.setBoolean(stmnt, idx, val);
}
/**
@@ -1851,8 +1857,6 @@ public class DBDictionary
/**
* Helper method that inserts a size clause for a given SQL type.
*
- * @see appendSize
- *
* @param typeName The SQL type e.g. INT
* @param size The size clause e.g. (10)
* @return The typeName + size clause. Usually the size clause
will
@@ -2776,12 +2780,11 @@ public class DBDictionary
/**
* Append <code>elem</code> to <code>selectSQL</code>.
* @param selectSQL The SQLBuffer to append to.
- * @param alias A {@link SQLBuffer} or a {@link String} to append.
+ * @param elem A {@link SQLBuffer} or a {@link String} to append.
*
* @since 1.1.0
*/
- protected void appendSelect(SQLBuffer selectSQL, Object elem, Select sel,
- int idx) {
+ protected void appendSelect(SQLBuffer selectSQL, Object elem, Select sel,
int idx) {
if (elem instanceof SQLBuffer)
selectSQL.append((SQLBuffer) elem);
else
@@ -3154,7 +3157,7 @@ public class DBDictionary
* getValidColumnName method of the DB dictionary should be invoked to make
* it valid.
*
- * @see getValidColumnName
+ * @see
#getValidColumnName(org.apache.openjpa.jdbc.identifier.DBIdentifier,
org.apache.openjpa.jdbc.schema.Table)
*/
public final Set<String> getInvalidColumnWordSet() {
return invalidColumnWordSet;
@@ -5396,11 +5399,10 @@ public class DBDictionary
* Validate that the given name is not longer than given maximum length.
Uses the unqualified name
* from the supplied {@link DBIdentifier} by default..
*
- * @param identifer The database identifier to check.
+ * @param identifier The database identifier to check.
* @param length Max length for this type of identifier
* @param msgKey message identifier for the exception.
- * @param qualified If true the qualified name of the DBIdentifier will be
used.
- *
+ *
* @throws {@link UserException} with the given message key if the given
name is indeed longer.
* @return the same name.
*/
@@ -5412,7 +5414,7 @@ public class DBDictionary
* Validate that the given name is not longer than given maximum length.
Conditionally uses the unqualified name
* from the supplied {@link DBIdentifier}.
*
- * @param identifer The database identifier to check.
+ * @param identifier The database identifier to check.
* @param length Max length for this type of identifier
* @param msgKey message identifier for the exception.
* @param qualified If true the qualified name of the DBIdentifier will be
used.
@@ -5465,7 +5467,7 @@ public class DBDictionary
}
/**
- * @param metadata the DatabaseMetaData to use to determine whether
delimiters can be supported
+ * @param metaData the DatabaseMetaData to use to determine whether
delimiters can be supported
*/
private void setSupportsDelimitedIdentifiers(DatabaseMetaData metaData) {
try {
@@ -5673,7 +5675,23 @@ public class DBDictionary
}
}
- protected boolean isUsingRange(long start, long end) {
+ public BooleanRepresentation getBooleanRepresentation() {
+ return booleanRepresentation;
+ }
+
+ public void setBooleanRepresentation(String booleanRepresentationKey) {
+ BooleanRepresentation evaluatedBooleanRepresentation = null;
+ if (booleanRepresentationKey != null &&
booleanRepresentationKey.length() > 0) {
+ ClassLoader cl = conf.getUserClassLoader();
+ evaluatedBooleanRepresentation =
BooleanRepresentation.Factory.valueOf(booleanRepresentationKey, cl);
+ }
+
+ booleanRepresentation = evaluatedBooleanRepresentation != null
+ ? evaluatedBooleanRepresentation
+ :
BooleanRepresentation.BooleanRepresentations.INT_10;
+ }
+
+ protected boolean isUsingRange(long start, long end) {
return isUsingOffset(start) || isUsingLimit(end);
}
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionaryFactory.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionaryFactory.java?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionaryFactory.java
(original)
+++
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/DBDictionaryFactory.java
Sun Jan 18 14:30:44 2015
@@ -215,8 +215,7 @@ public class DBDictionaryFactory {
/**
* Guess the dictionary class name to use based on the product string.
*/
- private static String dictionaryClassForString(String prod
- , JDBCConfiguration conf) {
+ private static String dictionaryClassForString(String prod,
JDBCConfiguration conf) {
if (StringUtils.isEmpty(prod))
return null;
prod = prod.toLowerCase();
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/PostgresDictionary.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/PostgresDictionary.java?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/PostgresDictionary.java
(original)
+++
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/PostgresDictionary.java
Sun Jan 18 14:30:44 2015
@@ -187,6 +187,7 @@ public class PostgresDictionary
"SET", "FLOAT4", "FLOAT8", "ABSTIME", "RELTIME", "TINTERVAL",
"MONEY",
}));
+ booleanRepresentation =
BooleanRepresentation.BooleanRepresentations.BOOLEAN;
supportsLockingWithDistinctClause = false;
supportsQueryTimeout = false;
@@ -303,15 +304,6 @@ public class PostgresDictionary
}
}
- @Override
- public void setBoolean(PreparedStatement stmnt, int idx, boolean val,
- Column col)
- throws SQLException {
- // postgres actually requires that a boolean be set: it cannot
- // handle a numeric argument.
- stmnt.setBoolean(idx, val);
- }
-
/**
* Handle XML and bytea/oid columns in a PostgreSQL way.
*/
Modified:
openjpa/trunk/openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/sql/localizer.properties
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/sql/localizer.properties?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/sql/localizer.properties
(original)
+++
openjpa/trunk/openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/sql/localizer.properties
Sun Jan 18 14:30:44 2015
@@ -231,4 +231,5 @@ jdbc4-setbinarystream-unsupported: The J
sequence-cache-warning: Setting the useNativeSequenceCache property on the
DBDictionary no longer has an \
effect. Code has been added to allow, by default, the functionality
provided in previous releases \
via the useNativeSequenceCache property.
+unknown-booleanRepresentation: Unknown BooleanRepresentation {0}. Value must
be one of {1}.
Added:
openjpa/trunk/openjpa-jdbc/src/test/java/org/apache/openjpa/jdbc/sql/TestBooleanRepresentation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/test/java/org/apache/openjpa/jdbc/sql/TestBooleanRepresentation.java?rev=1652761&view=auto
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/test/java/org/apache/openjpa/jdbc/sql/TestBooleanRepresentation.java
(added)
+++
openjpa/trunk/openjpa-jdbc/src/test/java/org/apache/openjpa/jdbc/sql/TestBooleanRepresentation.java
Sun Jan 18 14:30:44 2015
@@ -0,0 +1,159 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.openjpa.jdbc.sql;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+import org.apache.openjpa.lib.jdbc.DelegatingPreparedStatement;
+
+/**
+ * Test for the {@link org.apache.openjpa.jdbc.sql.BooleanRepresentation}
factory and default impls
+ */
+public class TestBooleanRepresentation extends TestCase {
+
+
+ public void testBooleanRepresentation() throws Exception {
+
+ checkBooleanRepresentation("BOOLEAN", Boolean.class, Boolean.TRUE,
Boolean.FALSE);
+ checkBooleanRepresentation("INT_10", Integer.class, 1, 0);
+ checkBooleanRepresentation("STRING_10", String.class, "1", "0");
+
+ checkBooleanRepresentation("STRING_YN", String.class, "Y", "N");
+ checkBooleanRepresentation("STRING_YN_LOWERCASE", String.class, "y",
"n");
+
+ checkBooleanRepresentation("STRING_TF", String.class, "T", "F");
+ checkBooleanRepresentation("STRING_TF_LOWERCASE", String.class, "t",
"f");
+
+ // and now up to more sophisticated ones:
+ checkBooleanRepresentation("oui/non", String.class, "oui", "non");
+
+ checkBooleanRepresentation(
+
"org.apache.openjpa.jdbc.sql.TestBooleanRepresentation$DummyTestBooleanRepresentation",
+ String.class, "somehowtrue", "somehowfalse");
+ }
+
+ private <T> void checkBooleanRepresentation(String representationKey,
final Class<T> expectedType,
+ final T yesRepresentation,
final T noRepresentation)
+ throws Exception {
+ ClassLoader cl = TestBooleanRepresentation.class.getClassLoader();
+ BooleanRepresentation booleanRepresentation =
BooleanRepresentation.Factory.valueOf(representationKey, cl);
+ Assert.assertNotNull(booleanRepresentation);
+
+ DummyPreparedStatement<T> dummyPreparedStatement = new
DummyPreparedStatement<T>(expectedType);
+
+ booleanRepresentation.setBoolean(dummyPreparedStatement, 1, true);
+ Assert.assertEquals(yesRepresentation,
dummyPreparedStatement.getBooleanRepresentationValue());
+
+ booleanRepresentation.setBoolean(dummyPreparedStatement, 1, false);
+ Assert.assertEquals(noRepresentation,
dummyPreparedStatement.getBooleanRepresentationValue());
+
+
+ // and also test getBoolean!
+ ResultSet yesRs = (ResultSet) Proxy.newProxyInstance(cl, new
Class[]{ResultSet.class},
+ new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
+ if (String.class.equals(expectedType) &&
!"getString".equals(method.getName()) ||
+ Boolean.class.equals(expectedType) &&
!"getBoolean".equals(method.getName()) ||
+ Integer.class.equals(expectedType) &&
!"getInt".equals(method.getName())) {
+ Assert.fail("wrong ResultSet method " + method.getName()
+ + "for expectedType " +
expectedType.getName());
+ }
+ return yesRepresentation;
+ }
+ });
+ Assert.assertTrue(booleanRepresentation.getBoolean(yesRs, 1));
+
+ ResultSet noRs = (ResultSet) Proxy.newProxyInstance(cl, new
Class[]{ResultSet.class},
+ new InvocationHandler() {
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
+ if (String.class.equals(expectedType) &&
!"getString".equals(method.getName()) ||
+ Boolean.class.equals(expectedType) &&
!"getBoolean".equals(method.getName()) ||
+ Integer.class.equals(expectedType) &&
!"getInt".equals(method.getName())) {
+ Assert.fail("wrong ResultSet method " + method.getName()
+ + "for expectedType " +
expectedType.getName());
+ }
+ return noRepresentation;
+ }
+ });
+ Assert.assertFalse(booleanRepresentation.getBoolean(noRs, 1));
+ }
+
+
+ /**
+ * A small trick to 'intercept' the PreparedStatement call inside the
BooleanRepresentation
+ */
+ public static class DummyPreparedStatement<T> extends
DelegatingPreparedStatement {
+ private final Class<T> expectedType;
+ private Object booleanRepresentationValue;
+
+
+ public DummyPreparedStatement(Class<T> expectedType) {
+ super(null, null);
+ this.expectedType = expectedType;
+ }
+
+ public T getBooleanRepresentationValue() {
+ return (T) booleanRepresentationValue;
+ }
+
+ public void setBooleanRepresentationValue(T
booleanRepresentationValue) {
+ this.booleanRepresentationValue = booleanRepresentationValue;
+ }
+
+ @Override
+ public void setBoolean(int idx, boolean b) throws SQLException {
+ Assert.assertEquals(Boolean.class, expectedType);
+ booleanRepresentationValue = b;
+ }
+
+ @Override
+ public void setString(int idx, String s) throws SQLException {
+ Assert.assertEquals(String.class, expectedType);
+ booleanRepresentationValue = s;
+ }
+
+ @Override
+ public void setInt(int idx, int i) throws SQLException {
+ Assert.assertEquals(Integer.class, expectedType);
+ booleanRepresentationValue = i;
+ }
+ }
+
+ public static class DummyTestBooleanRepresentation implements
BooleanRepresentation {
+ @Override
+ public void setBoolean(PreparedStatement stmnt, int columnIndex,
boolean val) throws SQLException {
+ stmnt.setString(columnIndex, val ? "somehowtrue" : "somehowfalse");
+ }
+
+ @Override
+ public boolean getBoolean(ResultSet rs, int columnIndex) throws
SQLException {
+ return "somehowtrue".equals(rs.getString(columnIndex));
+ }
+ }
+}
Modified: openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_conf.xml
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_conf.xml?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
--- openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_conf.xml (original)
+++ openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_conf.xml Sun Jan 18
14:30:44 2015
@@ -3568,8 +3568,9 @@ openjpa.ConnectionDriverName</literal></
<classname>org.apache.openjpa.jdbc.sql.DBDictionary</classname></ulink> to use
for database interaction. OpenJPA typically auto-configures the dictionary
based
on the JDBC URL, but you may have to set this property explicitly if you are
-using an unrecognized driver, or to plug in your own dictionary for a database
-OpenJPA does not support out-of-the-box. See
+using an unrecognized driver, to plug in your own dictionary for a database
+OpenJPA does not support out-of-the-box, or if you like to change the default
+configuration of an existing dictionary. See
<xref linkend="ref_guide_dbsetup_dbsupport"/> for details.
</para>
</section>
Modified: openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_dbsetup.xml
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_dbsetup.xml?rev=1652761&r1=1652760&r2=1652761&view=diff
==============================================================================
--- openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_dbsetup.xml
(original)
+++ openjpa/trunk/openjpa-project/src/doc/manual/ref_guide_dbsetup.xml Sun Jan
18 14:30:44 2015
@@ -1142,6 +1142,34 @@ the <literal>INSERT/UPDATE</literal> ope
generated by the <literal>mappingtool</literal>.
</para>
</listitem>
+
+
+
+ <!-- MSX TODO START DOCUMENT -->
+ <listitem id="DBDictionary.BooleanRepresentation">
+ <para>
+ <indexterm>
+ <primary>
+ DDL
+ </primary>
+ <secondary>
+ BooleanRepresentation
+ </secondary>
+ </indexterm>
+<literal>BooleanRepresentation</literal>:
+The overridden default representation for <literal>java.lang.Boolean</literal>
or
+<literal>boolean</literal> fields in JPA Entities. A
+<ulink url="../javadoc/org/apache/openjpa/jdbc/sql/BooleanRepresentation.html">
+<classname>org.apache.openjpa.jdbc.sql.BooleanRepresentation</classname></ulink>
+describes how Boolean values in entities get mapped into the database by
default.
+Note that you additionally might need to define the
<literal>BooleanTypeName</literal>
+<literal>BitTypeName</literal> settings to fit your selected
BooleanRepresenation.
+ </para>
+ </listitem>
+ <!-- MSX TODO END DOCUMENT -->
+
+
+
<listitem id="DBDictionary.BooleanTypeName">
<para>
<indexterm>
@@ -1152,9 +1180,9 @@ generated by the <literal>mappingtool</l
BooleanTypeName
</secondary>
</indexterm>
-<literal>BooleanTypeName</literal>:
-The overridden default column type for
-<literal>java.sql.Types.BOOLEAN</literal>. This is used only when the schema
+<literal>BooleanTypeName</literal>:
+The overridden default column type for
+<literal>java.sql.Types.BOOLEAN</literal>. This is used only when the schema
is generated by the <literal>mappingtool</literal>.
</para>
</listitem>
