openjpa-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From p..@apache.org
Subject svn commit: r423615 [12/44] - in /incubator/openjpa/trunk: ./ openjpa-jdbc-5/ openjpa-jdbc-5/src/ openjpa-jdbc-5/src/main/ openjpa-jdbc-5/src/main/java/ openjpa-jdbc-5/src/main/java/org/ openjpa-jdbc-5/src/main/java/org/apache/ openjpa-jdbc-5/src/main/...
Date Wed, 19 Jul 2006 21:35:07 GMT
Added: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JDBCValueOrder.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JDBCValueOrder.java?rev=423615&view=auto
==============================================================================
--- incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JDBCValueOrder.java
(added)
+++ incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JDBCValueOrder.java
Wed Jul 19 14:34:44 2006
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed 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.meta;
+
+import java.util.Comparator;
+
+import org.apache.openjpa.jdbc.sql.Joins;
+import org.apache.openjpa.jdbc.sql.Select;
+import org.apache.openjpa.meta.Order;
+
+/**
+ * Order by value columns, which are the primary key columns in the case
+ * of a relation field.
+ *
+ * @author Abe White
+ */
+class JDBCValueOrder
+    implements JDBCOrder {
+
+    private final FieldMapping _fm;
+    private final boolean _asc;
+
+    public JDBCValueOrder(FieldMapping fm, boolean asc) {
+        _fm = fm;
+        _asc = asc;
+    }
+
+    public String getName() {
+        return Order.ELEMENT;
+    }
+
+    public boolean isAscending() {
+        return _asc;
+    }
+
+    public Comparator getComparator() {
+        return null;
+    }
+
+    public boolean isInRelation() {
+        return _fm.getElement().getTypeMetaData() != null;
+    }
+
+    public void order(Select sel, ClassMapping elem, Joins joins) {
+        if (elem != null)
+            sel.orderBy(elem.getPrimaryKeyColumns(), _asc, joins, false);
+        else
+            sel.orderBy(_fm.getElementMapping().getColumns(), _asc,
+                joins, false);
+    }
+}

Propchange: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JDBCValueOrder.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JavaSQLTypes.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JavaSQLTypes.java?rev=423615&view=auto
==============================================================================
--- incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JavaSQLTypes.java
(added)
+++ incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JavaSQLTypes.java
Wed Jul 19 14:34:44 2006
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed 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.meta;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.sql.Time;
+import java.sql.Timestamp;
+
+import org.apache.openjpa.meta.JavaTypes;
+import serp.util.Numbers;
+
+/**
+ * Java SQL type constants.
+ *
+ * @author Abe White
+ */
+public class JavaSQLTypes
+    extends JavaTypes {
+
+    // constants for the sql types that aren't directly supported by
+    // OpenJPA; make sure these don't conflict with our standard metadata types
+    public static final int SQL_ARRAY = 1000;
+    public static final int ASCII_STREAM = 1001;
+    public static final int BINARY_STREAM = 1002;
+    public static final int BLOB = 1003;
+    public static final int BYTES = 1004;
+    public static final int CHAR_STREAM = 1005;
+    public static final int CLOB = 1006;
+    public static final int SQL_DATE = 1007;
+    public static final int SQL_OBJECT = 1008;
+    public static final int REF = 1009;
+    public static final int TIME = 1010;
+    public static final int TIMESTAMP = 1011;
+    public static final int JDBC_DEFAULT = 1012;
+
+    private static final Byte ZERO_BYTE = new Byte((byte) 0);
+    private static final Character ZERO_CHAR = new Character((char) 0);
+    private static final Double ZERO_DOUBLE = new Double(0);
+    private static final Float ZERO_FLOAT = new Float(0);
+    private static final Short ZERO_SHORT = new Short((short) 0);
+    private static final BigDecimal ZERO_BIGDECIMAL = new BigDecimal(0);
+
+    private static final Byte NONZERO_BYTE = new Byte((byte) 1);
+    private static final Character NONZERO_CHAR = new Character((char) 'a');
+    private static final Double NONZERO_DOUBLE = new Double(1);
+    private static final Float NONZERO_FLOAT = new Float(1);
+    private static final Short NONZERO_SHORT = new Short((short) 1);
+    private static final BigInteger NONZERO_BIGINTEGER = new BigInteger("1");
+    private static final BigDecimal NONZERO_BIGDECIMAL = new BigDecimal(1);
+
+    /**
+     * Return the proper date typecode.
+     */
+    public static int getDateTypeCode(Class dtype) {
+        if (dtype == java.util.Date.class)
+            return DATE;
+        if (dtype == java.sql.Date.class)
+            return SQL_DATE;
+        if (dtype == Timestamp.class)
+            return TIMESTAMP;
+        if (dtype == Time.class)
+            return TIME;
+        return OBJECT;
+    }
+
+    /**
+     * Return an empty value object for the given type code.
+     */
+    public static Object getEmptyValue(int type) {
+        switch (type) {
+            case JavaTypes.STRING:
+                return "";
+            case JavaTypes.BOOLEAN:
+            case JavaTypes.BOOLEAN_OBJ:
+                return Boolean.FALSE;
+            case JavaTypes.BYTE:
+            case JavaTypes.BYTE_OBJ:
+                return ZERO_BYTE;
+            case JavaTypes.CHAR:
+            case JavaTypes.CHAR_OBJ:
+                return ZERO_CHAR;
+            case JavaTypes.DOUBLE:
+            case JavaTypes.DOUBLE_OBJ:
+                return ZERO_DOUBLE;
+            case JavaTypes.FLOAT:
+            case JavaTypes.FLOAT_OBJ:
+                return ZERO_FLOAT;
+            case JavaTypes.INT:
+            case JavaTypes.INT_OBJ:
+                return Numbers.valueOf(0);
+            case JavaTypes.LONG:
+            case JavaTypes.LONG_OBJ:
+                return Numbers.valueOf(0L);
+            case JavaTypes.SHORT:
+            case JavaTypes.SHORT_OBJ:
+                return ZERO_SHORT;
+            case JavaTypes.BIGINTEGER:
+                return BigInteger.ZERO;
+            case JavaTypes.BIGDECIMAL:
+            case JavaTypes.NUMBER:
+                return ZERO_BIGDECIMAL;
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Return a non-empty value object for the given type code.
+     */
+    public static Object getNonEmptyValue(int type) {
+        switch (type) {
+            case JavaTypes.STRING:
+                return "x";
+            case JavaTypes.BOOLEAN:
+            case JavaTypes.BOOLEAN_OBJ:
+                return Boolean.TRUE;
+            case JavaTypes.BYTE:
+            case JavaTypes.BYTE_OBJ:
+                return NONZERO_BYTE;
+            case JavaTypes.CHAR:
+            case JavaTypes.CHAR_OBJ:
+                return NONZERO_CHAR;
+            case JavaTypes.DOUBLE:
+            case JavaTypes.DOUBLE_OBJ:
+                return NONZERO_DOUBLE;
+            case JavaTypes.FLOAT:
+            case JavaTypes.FLOAT_OBJ:
+                return NONZERO_FLOAT;
+            case JavaTypes.INT:
+            case JavaTypes.INT_OBJ:
+                return Numbers.valueOf(1);
+            case JavaTypes.LONG:
+            case JavaTypes.LONG_OBJ:
+                return Numbers.valueOf(1L);
+            case JavaTypes.SHORT:
+            case JavaTypes.SHORT_OBJ:
+                return NONZERO_SHORT;
+            case JavaTypes.BIGINTEGER:
+                return NONZERO_BIGINTEGER;
+            case JavaTypes.BIGDECIMAL:
+            case JavaTypes.NUMBER:
+                return NONZERO_BIGDECIMAL;
+            default:
+                return null;
+        }
+    }
+}

Propchange: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/JavaSQLTypes.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/Joinable.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/Joinable.java?rev=423615&view=auto
==============================================================================
--- incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/Joinable.java
(added)
+++ incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/Joinable.java
Wed Jul 19 14:34:44 2006
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed 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.meta;
+
+import java.sql.SQLException;
+
+import org.apache.openjpa.jdbc.kernel.JDBCStore;
+import org.apache.openjpa.jdbc.schema.Column;
+import org.apache.openjpa.jdbc.schema.ForeignKey;
+import org.apache.openjpa.jdbc.sql.Joins;
+import org.apache.openjpa.jdbc.sql.Result;
+import org.apache.openjpa.kernel.OpenJPAStateManager;
+
+/**
+ * Represents a value that can be joined to. Any column that a user
+ * joins to must be "owned" by an entity that implements this interface.
+ * The system maps columns to joinables to be able to decompose oids and
+ * field values into individual join values on a per-column basis. This
+ * allows us to support joins to only some of the columns of a mapping, and
+ * to be loose with the ordering of foreign key columns relative to the
+ * ordering of the joined-to columns. Having a separate interface for
+ * joinables also allows us to perform tricks such as a vertically-mapped
+ * application identity subclass transparently transforming columns of its
+ * foreign key to the corresponding primary key fields in the base class.
+ *
+ * @author Abe White
+ */
+public interface Joinable {
+
+    /**
+     * Return the field index of this joinable, or -1 if not a field.
+     */
+    public int getFieldIndex();
+
+    /**
+     * Return the value for this joinable from the given result, using the
+     * given columns. If the given foreign key is non-null, use the foreign
+     * key's columns by translating the given columns through
+     * {@link ForeignKey#getColumn}.
+     */
+    public Object getPrimaryKeyValue(Result res, Column[] cols, ForeignKey fk,
+        Joins joins)
+        throws SQLException;
+
+    /**
+     * The columns managed by this joinable.
+     */
+    public Column[] getColumns();
+
+    /**
+     * Return the join value of the given column.
+     *
+     * @param val the value of the field for this joinable
+     * @param col the column of this joinable whose value to return
+     */
+    public Object getJoinValue(Object val, Column col, JDBCStore store);
+
+    /**
+     * Return the join value of the given column.
+     *
+     * @param sm the instance from which to get the value
+     * @param col the column whose value to return
+     */
+    public Object getJoinValue(OpenJPAStateManager sm, Column col,
+        JDBCStore store);
+
+    /**
+     * Use the given auto-assigned value to set this join value's field
+     * on the given instance.
+     */
+    public void setAutoAssignedValue(OpenJPAStateManager sm, JDBCStore store,
+        Column col, Object autogen);
+}

Propchange: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/Joinable.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaults.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaults.java?rev=423615&view=auto
==============================================================================
--- incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaults.java
(added)
+++ incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaults.java
Wed Jul 19 14:34:44 2006
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed 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.meta;
+
+import org.apache.openjpa.jdbc.schema.Column;
+import org.apache.openjpa.jdbc.schema.ForeignKey;
+import org.apache.openjpa.jdbc.schema.Index;
+import org.apache.openjpa.jdbc.schema.Schema;
+import org.apache.openjpa.jdbc.schema.Table;
+import org.apache.openjpa.jdbc.schema.Unique;
+
+/**
+ * Generates default names for tables, columns, indexes, constraints, etc.
+ *
+ * @author Abe White
+ */
+public interface MappingDefaults {
+
+    /**
+     * Whether to fill in missing mapping information at runtime with the
+     * default values supplied by this plugin. A value of false means that
+     * all mapping information must be present at runtime.
+     */
+    public boolean defaultMissingInfo();
+
+    /**
+     * The default for whether relations use the related object's
+     * expected class as part of the join criteria.
+     */
+    public boolean useClassCriteria();
+
+    /**
+     * Default mapping strategy when there is no explicit strategy
+     * and no hierarchy strategy given.
+     *
+     * @param cls the class; will not be mapped, but superclass and raw
+     * {@link MappingInfo} will be available
+     * @param adapt whether we can adapt the mapping or schema
+     * @return the strategy alias or a strategy instance, or null
+     */
+    public Object getStrategy(ClassMapping cls, boolean adapt);
+
+    /**
+     * Default version mapping strategy when there is no explicit strategy.
+     *
+     * @param vers the version; will not be mapped, but raw
+     * {@link MappingInfo} will be available
+     * @param adapt whether we can adapt the mapping or schema
+     * @return the strategy alias or a strategy instance, or null
+     */
+    public Object getStrategy(Version vers, boolean adapt);
+
+    /**
+     * Default discriminator mapping strategy when there is no explicit
+     * strategy.
+     *
+     * @param disc the discriminator; will not be mapped, but raw
+     * {@link MappingInfo} will be available
+     * @param adapt whether we can adapt the mapping or schema
+     * @return the strategy alias or a strategy instance, or null
+     */
+    public Object getStrategy(Discriminator disc, boolean adapt);
+
+    /**
+     * Custom handler or strategy for the given field, or null if none
+     * has been registered.
+     *
+     * @param vm the value mapping; will not be mapped, but raw
+     * {@link MappingInfo} will be available
+     * @param type the value type
+     * @param adapt whether we can adapt the mapping or schema
+     * @return the handler/strategy alias or instance, or null
+     */
+    public Object getStrategy(ValueMapping vm, Class type, boolean adapt);
+
+    /**
+     * Return the default discriminator value for the given instance.
+     */
+    public Object getDiscriminatorValue(Discriminator disc, boolean adapt);
+
+    /**
+     * Return the default table name for the given class. This method is
+     * only called for classes mapped to their own table.
+     */
+    public String getTableName(ClassMapping cls, Schema defaultSchema);
+
+    /**
+     * Return the default secondary table name for the given field. This
+     * method is only called for fields whose strategy requires a secondary
+     * table.
+     */
+    public String getTableName(FieldMapping fm, Schema defaultSchema);
+
+    /**
+     * Fill in default information for the given datastore identity columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     */
+    public void populateDataStoreIdColumns(ClassMapping cls, Table table,
+        Column[] cols);
+
+    /**
+     * Fill in default information for the given version columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     */
+    public void populateColumns(Version vers, Table table, Column[] cols);
+
+    /**
+     * Fill in default information for the given discriminator columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     */
+    public void populateColumns(Discriminator disc, Table table,
+        Column[] cols);
+
+    /**
+     * Fill in default information for the given column used to join a class
+     * to its superclass table. The column will be a clone of the target
+     * column, or have its name and Java type set in the case of a constant
+     * target.
+     *
+     * @param target the target of this column in the join; may be
+     * another column or a constant value
+     * @param pos the index of this column in the logical foreign key
+     * @param cols the number of columns in the logical foreign key
+     */
+    public void populateJoinColumn(ClassMapping cm, Table local, Table foreign,
+        Column col, Object target, int pos, int cols);
+
+    /**
+     * Fill in default information for the given column used to join a field
+     * to its defining class' table. The column will be a clone of the target
+     * column, or have its name and Java type set in the case of a constant
+     * target.
+     *
+     * @param target the target of this column in the join; may be
+     * another column or a constant value
+     * @param pos the index of this column in the logical foreign key
+     * @param cols the number of columns in the logical foreign key
+     */
+    public void populateJoinColumn(FieldMapping fm, Table local, Table foreign,
+        Column col, Object target, int pos, int cols);
+
+    /**
+     * Fill in default information for the given column used to join a value
+     * to its related type. The column will be a clone of the target
+     * column, or have its name and Java type set in the case of a constant
+     * target.
+     *
+     * @param name base name for value, as decided by mapping
+     * @param target the target of this column in the join; may be
+     * another column or a constant value
+     * @param inverse whether this is an inverse foreign key
+     * @param pos the index of this column in the logical foreign key
+     * @param cols the number of columns in the logical foreign key
+     */
+    public void populateForeignKeyColumn(ValueMapping vm, String name,
+        Table local, Table foreign, Column col, Object target, boolean inverse,
+        int pos, int cols);
+
+    /**
+     * Fill in default information for the given value columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     *
+     * @param name base name for value, as decided by mapping
+     */
+    public void populateColumns(ValueMapping vm, String name, Table table,
+        Column[] cols);
+
+    /**
+     * Fill in default information for the given order columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     *
+     * @return false if the given field should not have order columns
+     * by default; fill in default information even when returning
+     * false in case the user forces ordering
+     */
+    public boolean populateOrderColumns(FieldMapping fm, Table table,
+        Column[] cols);
+
+    /**
+     * Fill in default information for the given null indicator columns.
+     * The columns' name and Java type will already be populated with generic
+     * defaults that may be replaced.
+     *
+     * @param name base name for value, as decided by mapping
+     * @return false if the given value should not have null indicator
+     * columns by default; fill in default information even
+     * when returning false in case the user forces an indicator
+     */
+    public boolean populateNullIndicatorColumns(ValueMapping vm, String name,
+        Table table, Column[] cols);
+
+    /**
+     * Return a default foreign key for the join from this class' table to its
+     * superclass' table, or null for a logical foreign key only. Do not
+     * add columns to the key or add the key to the table; only fill in
+     * its information such as name, delete action, etc.
+     */
+    public ForeignKey getJoinForeignKey(ClassMapping cls, Table local,
+        Table foreign);
+
+    /**
+     * Return a default foreign key for the join from this field's table to its
+     * defining class' table, or null for a logical foreign key only. Do not
+     * add columns to the key or add the key to the table; only fill in
+     * its information such as name, delete action, etc.
+     */
+    public ForeignKey getJoinForeignKey(FieldMapping fm, Table local,
+        Table foreign);
+
+    /**
+     * Return a default foreign key for the join from this value to its
+     * related type, or null for a logical foreign key only. Do not
+     * add columns to the key or add the key to the table; only fill in
+     * its information such as name, delete action, etc.
+     *
+     * @param name base name for value, as decided by mapping
+     * @param inverse whether this is an inverse key
+     */
+    public ForeignKey getForeignKey(ValueMapping vm, String name, Table local,
+        Table foreign, boolean inverse);
+
+    /**
+     * Return a default index for the join, or null if the
+     * join columns should not be indexed by default. Do not
+     * add columns to the index or add the index to the table; only fill in
+     * its information such as name, uniqueness, etc.
+     */
+    public Index getJoinIndex(FieldMapping fm, Table table, Column[] cols);
+
+    /**
+     * Return a default index for the value, or null if the value columns
+     * should not be indexed by default. Do not add columns to the index or
+     * add the index to the table; only fill in its information such as name,
+     * uniqueness, etc.
+     *
+     * @param name base name for value, as decided by mapping
+     */
+    public Index getIndex(ValueMapping vm, String name, Table table,
+        Column[] cols);
+
+    /**
+     * Return a default index for the version, or null if the
+     * version columns should not be indexed by default. Do not
+     * add columns to the index or add the index to the table; only fill in
+     * its information such as name, uniqueness, etc.
+     */
+    public Index getIndex(Version vers, Table table, Column[] cols);
+
+    /**
+     * Return a default index for the discriminator, or null if the
+     * discriminator columns should not be indexed by default. Do not
+     * add columns to the index or add the index to the table; only fill in
+     * its information such as name, uniqueness, etc.
+     */
+    public Index getIndex(Discriminator disc, Table table, Column[] cols);
+
+    /**
+     * Return a default constraint for the join, or null if the join columns
+     * should not be constrained by default. Do not add columns to the
+     * constraint or add the constraint to the table; only fill in its
+     * information such as name, deferrability, etc.
+     */
+    public Unique getJoinUnique(FieldMapping fm, Table table, Column[] cols);
+
+    /**
+     * Return a default constraint for the value, or null if the value columns
+     * should not be constrained by default. Do not add columns to the
+     * constraint or add the constraint to the table; only fill in its
+     * information such as name, deferrability, etc.
+     *
+     * @param name base name for value, as decided by mapping
+     */
+    public Unique getUnique(ValueMapping vm, String name, Table table,
+        Column[] cols);
+
+    /**
+     * Return the name of the primary key for the table of the given class,
+     * or null for database default.
+     */
+    public String getPrimaryKeyName(ClassMapping cm, Table table);
+
+    /**
+     * If desired, install a primary key on the given secondary table.
+     */
+    public void installPrimaryKey(FieldMapping fm, Table table);
+}

Propchange: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaults.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaultsImpl.java
URL: http://svn.apache.org/viewvc/incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaultsImpl.java?rev=423615&view=auto
==============================================================================
--- incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaultsImpl.java
(added)
+++ incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaultsImpl.java
Wed Jul 19 14:34:44 2006
@@ -0,0 +1,703 @@
+/*
+ * Copyright 2006 The Apache Software Foundation.
+ *
+ * Licensed 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.meta;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
+import org.apache.openjpa.jdbc.meta.strats.UntypedPCValueHandler;
+import org.apache.openjpa.jdbc.schema.Column;
+import org.apache.openjpa.jdbc.schema.ForeignKey;
+import org.apache.openjpa.jdbc.schema.Index;
+import org.apache.openjpa.jdbc.schema.Schema;
+import org.apache.openjpa.jdbc.schema.Table;
+import org.apache.openjpa.jdbc.schema.Unique;
+import org.apache.openjpa.jdbc.sql.DBDictionary;
+import org.apache.openjpa.lib.conf.Configurable;
+import org.apache.openjpa.lib.conf.Configuration;
+import org.apache.openjpa.lib.conf.Configurations;
+import org.apache.openjpa.lib.util.JavaVersions;
+import org.apache.openjpa.meta.JavaTypes;
+import serp.util.Strings;
+
+/**
+ * Default implementation of {@link MappingDefaults}.
+ *
+ * @author Abe White
+ */
+public class MappingDefaultsImpl
+    implements MappingDefaults, Configurable {
+
+    protected DBDictionary dict = null;
+    private String _baseClassStrategy = null;
+    private String _subclassStrategy = null;
+    private String _versionStrategy = null;
+    private String _discStrategy = null;
+    private final Map _fieldMap = new HashMap();
+    private boolean _defMissing = false;
+    private boolean _classCriteria = false;
+    private int _joinFKAction = ForeignKey.ACTION_NONE;
+    private int _fkAction = ForeignKey.ACTION_NONE;
+    private boolean _defer = false;
+    private boolean _indexFK = true;
+    private boolean _indexDisc = true;
+    private boolean _indexVers = false;
+    private boolean _orderLists = true;
+    private boolean _addNullInd = false;
+    private boolean _ordinalEnum = false;
+    private boolean _stringifyUnmapped = false;
+    private String _dsIdName = null;
+    private String _versName = null;
+    private String _discName = null;
+    private String _orderName = null;
+    private String _nullIndName = null;
+
+    /**
+     * Default base class strategy alias.
+     */
+    public String getBaseClassStrategy() {
+        return _baseClassStrategy;
+    }
+
+    /**
+     * Default base class strategy alias.
+     */
+    public void setBaseClassStrategy(String baseClassStrategy) {
+        _baseClassStrategy = baseClassStrategy;
+    }
+
+    /**
+     * Default subclass strategy alias.
+     */
+    public String getSubclassStrategy() {
+        return _subclassStrategy;
+    }
+
+    /**
+     * Default subclass strategy alias.
+     */
+    public void setSubclassStrategy(String subclassStrategy) {
+        _subclassStrategy = subclassStrategy;
+    }
+
+    /**
+     * Default version strategy alias.
+     */
+    public String getVersionStrategy() {
+        return _versionStrategy;
+    }
+
+    /**
+     * Default version strategy alias.
+     */
+    public void setVersionStrategy(String versionStrategy) {
+        _versionStrategy = versionStrategy;
+    }
+
+    /**
+     * Default discriminator strategy alias.
+     */
+    public String getDiscriminatorStrategy() {
+        return _discStrategy;
+    }
+
+    /**
+     * Default discriminator strategy alias.
+     */
+    public void setDiscriminatorStrategy(String discStrategy) {
+        _discStrategy = discStrategy;
+    }
+
+    /**
+     * Property string mapping field type names to value handler or field
+     * mapping class names. For auto-configuration.
+     */
+    public void setFieldStrategies(String fieldMapString) {
+        Properties props = Configurations.parseProperties(fieldMapString);
+        if (props != null)
+            _fieldMap.putAll(props);
+    }
+
+    /**
+     * Association of a field value type name with the handler or strategy
+     * class name.
+     */
+    public void setFieldStrategy(String valueType, String handlerType) {
+        if (handlerType == null)
+            _fieldMap.remove(valueType);
+        else
+            _fieldMap.put(valueType, handlerType);
+    }
+
+    /**
+     * Association of a field value type name with the handler or strategy
+     * class name.
+     */
+    public String getFieldStrategy(String valueType) {
+        return (String) _fieldMap.get(valueType);
+    }
+
+    /**
+     * Whether to store enums as the ordinal value rather than the enum name.
+     * Defaults to false.
+     */
+    public boolean getStoreEnumOrdinal() {
+        return _ordinalEnum;
+    }
+
+    /**
+     * Whether to store enums as the ordinal value rather than the enum name.
+     * Defaults to false.
+     */
+    public void setStoreEnumOrdinal(boolean ordinal) {
+        _ordinalEnum = ordinal;
+    }
+
+    /**
+     * Whether to store a relation to an unmapped class by stringifying the
+     * oid of the related object, rather than storing primary key values.
+     */
+    public boolean getStoreUnmappedObjectIdString() {
+        return _stringifyUnmapped;
+    }
+
+    /**
+     * Whether to store a relation to an unmapped class by stringifying the
+     * oid of the related object, rather than storing primary key values.
+     */
+    public void setStoreUnmappedObjectIdString(boolean stringify) {
+        _stringifyUnmapped = stringify;
+    }
+
+    /**
+     * Default foreign key action for join keys. Defaults to logical keys.
+     */
+    public int getJoinForeignKeyDeleteAction() {
+        return _joinFKAction;
+    }
+
+    /**
+     * Default foreign key action for join keys. Defaults to logical keys.
+     */
+    public void setJoinForeignKeyDeleteAction(int joinFKAction) {
+        _joinFKAction = joinFKAction;
+    }
+
+    /**
+     * Default foreign key action name for join keys. Used in auto
+     * configuration.
+     */
+    public void setJoinForeignKeyDeleteAction(String joinFKAction) {
+        _joinFKAction = ForeignKey.getAction(joinFKAction);
+    }
+
+    /**
+     * Default foreign key action for relation keys. Defaults to logical keys.
+     */
+    public int getForeignKeyDeleteAction() {
+        return _fkAction;
+    }
+
+    /**
+     * Default foreign key action for relation keys. Defaults to logical keys.
+     */
+    public void setForeignKeyDeleteAction(int fkAction) {
+        _fkAction = fkAction;
+    }
+
+    /**
+     * Default foreign key action name for relation keys. Used in auto
+     * configuration.
+     */
+    public void setForeignKeyDeleteAction(String fkAction) {
+        _fkAction = ForeignKey.getAction(fkAction);
+    }
+
+    /**
+     * Whether to index logical foreign keys by default. Defaults to true.
+     */
+    public boolean getIndexLogicalForeignKeys() {
+        return _indexFK;
+    }
+
+    /**
+     * Whether to index logical foreign keys by default. Defaults to true.
+     */
+    public void setIndexLogicalForeignKeys(boolean indexFK) {
+        _indexFK = indexFK;
+    }
+
+    /**
+     * Whether to index discriminator columns by default. Defaults to true.
+     */
+    public boolean getIndexDiscriminator() {
+        return _indexDisc;
+    }
+
+    /**
+     * Whether to index discriminator columns by default. Defaults to true.
+     */
+    public void setIndexDiscriminator(boolean indexDisc) {
+        _indexDisc = indexDisc;
+    }
+
+    /**
+     * Whether to index version columns by default. Defaults to true.
+     */
+    public boolean getIndexVersion() {
+        return _indexVers;
+    }
+
+    /**
+     * Whether to index version columns by default. Defaults to true.
+     */
+    public void setIndexVersion(boolean indexVers) {
+        _indexVers = indexVers;
+    }
+
+    /**
+     * Whether to order lists and arrays using a dedicated ordering column
+     * by default.
+     */
+    public boolean getOrderLists() {
+        return _orderLists;
+    }
+
+    /**
+     * Whether to order lists and arrays using a dedicated ordering column
+     * by default.
+     */
+    public void setOrderLists(boolean orderLists) {
+        _orderLists = orderLists;
+    }
+
+    /**
+     * Whether to add a synthetic null indicator column to embedded mappings
+     * by default.
+     */
+    public boolean getAddNullIndicator() {
+        return _addNullInd;
+    }
+
+    /**
+     * Whether to add a synthetic null indicator column to embedded mappings
+     * by default.
+     */
+    public void setAddNullIndicator(boolean addNullInd) {
+        _addNullInd = addNullInd;
+    }
+
+    /**
+     * Whether to defer constraints by default. Defaults to false.
+     */
+    public boolean getDeferConstraints() {
+        return _defer;
+    }
+
+    /**
+     * Whether to defer constraints by default. Defaults to false.
+     */
+    public void setDeferConstraints(boolean defer) {
+        _defer = defer;
+    }
+
+    /**
+     * Default base name for datastore identity columns, or null to the
+     * mapping's built-in name.
+     */
+    public String getDataStoreIdColumnName() {
+        return _dsIdName;
+    }
+
+    /**
+     * Default base name for datastore identity columns, or null to the
+     * mapping's built-in name.
+     */
+    public void setDataStoreIdColumnName(String dsIdName) {
+        _dsIdName = dsIdName;
+    }
+
+    /**
+     * Default base name for version identity columns, or null to the mapping's
+     * built-in name. This name may be combined with lock group names.
+     */
+    public String getVersionColumnName() {
+        return _versName;
+    }
+
+    /**
+     * Default base name for version identity columns, or null to the mapping's
+     * built-in name. This name may be combined with lock group names.
+     */
+    public void setVersionColumnName(String versName) {
+        _versName = versName;
+    }
+
+    /**
+     * Default base name for discriminator columns, or null to the mapping's
+     * built-in name.
+     */
+    public String getDiscriminatorColumnName() {
+        return _discName;
+    }
+
+    /**
+     * Default base name for discriminator columns, or null to the mapping's
+     * built-in name.
+     */
+    public void setDiscriminatorColumnName(String discName) {
+        _discName = discName;
+    }
+
+    /**
+     * Default base name for order columns, or null to the mapping's
+     * built-in name.
+     */
+    public String getOrderColumnName() {
+        return _orderName;
+    }
+
+    /**
+     * Default base name for order columns, or null to the mapping's
+     * built-in name.
+     */
+    public void setOrderColumnName(String orderName) {
+        _orderName = orderName;
+    }
+
+    /**
+     * Default base name for null indicator columns, or null to the mapping's
+     * built-in name.
+     */
+    public String getNullIndicatorColumnName() {
+        return _nullIndName;
+    }
+
+    /**
+     * Default base name for null indicator columns, or null to the mapping's
+     * built-in name.
+     */
+    public void setNullIndicatorColumnName(String nullIndName) {
+        _nullIndName = nullIndName;
+    }
+
+    public boolean defaultMissingInfo() {
+        return _defMissing;
+    }
+
+    public void setDefaultMissingInfo(boolean defMissing) {
+        _defMissing = defMissing;
+    }
+
+    public boolean useClassCriteria() {
+        return _classCriteria;
+    }
+
+    public void setUseClassCriteria(boolean classCriteria) {
+        _classCriteria = classCriteria;
+    }
+
+    public Object getStrategy(ClassMapping cls, boolean adapt) {
+        if (adapt || defaultMissingInfo())
+            return (cls.getMappedPCSuperclassMapping() == null)
+                ? _baseClassStrategy : _subclassStrategy;
+        return null;
+    }
+
+    public Object getStrategy(Version vers, boolean adapt) {
+        ClassMapping cls = vers.getClassMapping();
+        if ((adapt || defaultMissingInfo())
+            && cls.getJoinablePCSuperclassMapping() == null
+            && cls.getVersionField() == null)
+            return _versionStrategy;
+        return null;
+    }
+
+    public Object getStrategy(Discriminator disc, boolean adapt) {
+        ClassMapping cls = disc.getClassMapping();
+        if ((adapt || defaultMissingInfo())
+            && cls.getJoinablePCSuperclassMapping() == null
+            && disc.getMappingInfo().getValue() == null)
+            return _discStrategy;
+        return null;
+    }
+
+    public Object getStrategy(ValueMapping vm, Class type, boolean adapt) {
+        Object ret = _fieldMap.get(type.getName());
+        if (ret != null)
+            return ret;
+        if (_stringifyUnmapped && vm.getTypeMapping() != null
+            && !vm.getTypeMapping().isMapped())
+            return UntypedPCValueHandler.getInstance();
+        if (_ordinalEnum && !vm.isSerialized()
+            && JavaVersions.isEnumeration(type))
+            return "org.apache.openjpa.jdbc.meta.strats.EnumValueHandler(StoreOrdinal=true)";
+        return null;
+    }
+
+    public Object getDiscriminatorValue(Discriminator disc, boolean adapt) {
+        if (!adapt && !defaultMissingInfo())
+            return null;
+
+        // WARNING: CHANGING THIS WILL INVALIDATE EXISTING DATA IF DEFAULTING
+        // MISSING MAPPING INFO
+        return Strings.getClassName(disc.getClassMapping().
+            getDescribedType());
+    }
+
+    public String getTableName(ClassMapping cls, Schema schema) {
+        String name = Strings.getClassName(cls.getDescribedType()).
+            replace('$', '_');
+        if (!_defMissing)
+            name = dict.getValidTableName(name, schema);
+        return name;
+    }
+
+    public String getTableName(FieldMapping fm, Schema schema) {
+        String name = fm.getName();
+        Table table = fm.getDefiningMapping().getTable();
+        if (table != null) {
+            String tableName = table.getName();
+            if (tableName.length() > 5)
+                tableName = tableName.substring(0, 5);
+            name = tableName + "_" + name;
+        }
+        if (!_defMissing)
+            name = dict.getValidTableName(name, schema);
+        return name;
+    }
+
+    public void populateDataStoreIdColumns(ClassMapping cls, Table table,
+        Column[] cols) {
+        for (int i = 0; i < cols.length; i++) {
+            if (_dsIdName != null && cols.length == 1)
+                cols[i].setName(_dsIdName);
+            else if (_dsIdName != null)
+                cols[i].setName(_dsIdName + i);
+            correctName(table, cols[i]);
+        }
+    }
+
+    /**
+     * Correct the given column's name.
+     */
+    protected void correctName(Table table, Column col) {
+        if (!_defMissing)
+            col.setName(dict.getValidColumnName(col.getName(), table));
+    }
+
+    public void populateColumns(Version vers, Table table, Column[] cols) {
+        for (int i = 0; i < cols.length; i++) {
+            if (_versName != null && cols.length == 1)
+                cols[i].setName(_versName);
+            else if (_versName != null) {
+                if (i == 0)
+                    cols[i].setName(_versName);
+                else
+                    cols[i].setName(_versName + "_" + i);
+            } else if (_versName != null)
+                cols[i].setName(_versName + i);
+            correctName(table, cols[i]);
+        }
+    }
+
+    public void populateColumns(Discriminator disc, Table table,
+        Column[] cols) {
+        for (int i = 0; i < cols.length; i++) {
+            if (_discName != null && cols.length == 1)
+                cols[i].setName(_discName);
+            else if (_discName != null)
+                cols[i].setName(_discName + i);
+            correctName(table, cols[i]);
+        }
+    }
+
+    public void populateJoinColumn(ClassMapping cm, Table local, Table foreign,
+        Column col, Object target, int pos, int cols) {
+        correctName(local, col);
+    }
+
+    public void populateJoinColumn(FieldMapping fm, Table local, Table foreign,
+        Column col, Object target, int pos, int cols) {
+        correctName(local, col);
+    }
+
+    public void populateForeignKeyColumn(ValueMapping vm, String name,
+        Table local, Table foreign, Column col, Object target, boolean inverse,
+        int pos, int cols) {
+        if (cols == 1)
+            col.setName(name);
+        else if (target instanceof Column)
+            col.setName(name + "_" + ((Column) target).getName());
+        correctName(local, col);
+    }
+
+    public void populateColumns(ValueMapping vm, String name, Table table,
+        Column[] cols) {
+        for (int i = 0; i < cols.length; i++)
+            correctName(table, cols[i]);
+    }
+
+    public boolean populateOrderColumns(FieldMapping fm, Table table,
+        Column[] cols) {
+        for (int i = 0; i < cols.length; i++) {
+            if (_orderName != null && cols.length == 1)
+                cols[i].setName(_orderName);
+            else if (_orderName != null)
+                cols[i].setName(_orderName + i);
+            correctName(table, cols[i]);
+        }
+        return _orderLists && (JavaTypes.ARRAY == fm.getTypeCode()
+            || List.class.isAssignableFrom(fm.getType()));
+    }
+
+    public boolean populateNullIndicatorColumns(ValueMapping vm, String name,
+        Table table, Column[] cols) {
+        for (int i = 0; i < cols.length; i++) {
+            if (_nullIndName != null && cols.length == 1)
+                cols[i].setName(_nullIndName);
+            else if (_nullIndName != null)
+                cols[i].setName(_nullIndName + i);
+            correctName(table, cols[i]);
+        }
+        return _addNullInd;
+    }
+
+    public ForeignKey getJoinForeignKey(ClassMapping cls, Table local,
+        Table foreign) {
+        if (_joinFKAction == ForeignKey.ACTION_NONE)
+            return null;
+        ForeignKey fk = new ForeignKey();
+        fk.setDeleteAction(_joinFKAction);
+        fk.setDeferred(_defer);
+        return fk;
+    }
+
+    public ForeignKey getJoinForeignKey(FieldMapping fm, Table local,
+        Table foreign) {
+        if (_joinFKAction == ForeignKey.ACTION_NONE)
+            return null;
+        ForeignKey fk = new ForeignKey();
+        fk.setDeleteAction(_joinFKAction);
+        fk.setDeferred(_defer);
+        return fk;
+    }
+
+    public ForeignKey getForeignKey(ValueMapping vm, String name, Table local,
+        Table foreign, boolean inverse) {
+        if (_fkAction == ForeignKey.ACTION_NONE)
+            return null;
+        ForeignKey fk = new ForeignKey();
+        fk.setDeleteAction(_fkAction);
+        fk.setDeferred(_defer);
+        return fk;
+    }
+
+    public Index getJoinIndex(FieldMapping fm, Table table, Column[] cols) {
+        if (!_indexFK || fm.getJoinForeignKey() == null
+            || !fm.getJoinForeignKey().isLogical())
+            return null;
+        if (areAllPrimaryKeyColumns(cols))
+            return null;
+
+        Index idx = new Index();
+        idx.setName(getIndexName(null, table, cols));
+        return idx;
+    }
+
+    /**
+     * Return whether all the given columns are primary key columns.
+     */
+    protected boolean areAllPrimaryKeyColumns(Column[] cols) {
+        for (int i = 0; i < cols.length; i++)
+            if (!cols[i].isPrimaryKey())
+                return false;
+        return true;
+    }
+
+    /**
+     * Generate an index name.
+     */
+    protected String getIndexName(String name, Table table, Column[] cols) {
+        // always use dict for index names because no spec mandates them
+        // based on defaults
+        if (name == null)
+            name = cols[0].getName();
+        return dict.getValidIndexName(name, table);
+    }
+
+    public Index getIndex(ValueMapping vm, String name, Table table,
+        Column[] cols) {
+        if (!_indexFK || vm.getForeignKey() == null
+            || !vm.getForeignKey().isLogical())
+            return null;
+        if (areAllPrimaryKeyColumns(cols))
+            return null;
+
+        Index idx = new Index();
+        idx.setName(getIndexName(name, table, cols));
+        return idx;
+    }
+
+    public Index getIndex(Version vers, Table table, Column[] cols) {
+        if (!_indexVers)
+            return null;
+        Index idx = new Index();
+        idx.setName(getIndexName(_versName, table, cols));
+        return idx;
+    }
+
+    public Index getIndex(Discriminator disc, Table table, Column[] cols) {
+        if (!_indexDisc)
+            return null;
+        Index idx = new Index();
+        idx.setName(getIndexName(_discName, table, cols));
+        return idx;
+    }
+
+    public Unique getJoinUnique(FieldMapping fm, Table table, Column[] cols) {
+        return null;
+    }
+
+    public Unique getUnique(ValueMapping vm, String name, Table table,
+        Column[] cols) {
+        return null;
+    }
+
+    public String getPrimaryKeyName(ClassMapping cm, Table table) {
+        return null;
+    }
+
+    public void installPrimaryKey(FieldMapping fm, Table table) {
+    }
+
+    ///////////////////////////////
+    // Configurable implementation
+    ///////////////////////////////
+
+    public void setConfiguration(Configuration conf) {
+        dict = ((JDBCConfiguration) conf).getDBDictionaryInstance();
+    }
+
+    public void startConfiguration() {
+    }
+
+    public void endConfiguration() {
+    }
+}

Propchange: incubator/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/meta/MappingDefaultsImpl.java
------------------------------------------------------------------------------
    svn:executable = *



Mime
View raw message