1 /*

     2  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package javax.sql.rowset.serial;

    27 

    28 import java.sql.*;

    29 import javax.sql.*;

    30 import java.io.*;

    31 import java.math.*;

    32 import java.util.Arrays;

    33 import java.util.Map;

    34 import java.util.Vector;

    35 

    36 import javax.sql.rowset.*;

    37 

    38 /**

    39  * A serialized mapping in the Java programming language of an SQL

    40  * structured type. Each attribute that is not already serialized

    41  * is mapped to a serialized form, and if an attribute is itself

    42  * a structured type, each of its attributes that is not already

    43  * serialized is mapped to a serialized form.

    44  * <P>

    45  * In addition, the structured type is custom mapped to a class in the

    46  * Java programming language if there is such a mapping, as are

    47  * its attributes, if appropriate.

    48  * <P>

    49  * The <code>SerialStruct</code> class provides a constructor for creating

    50  * an instance from a <code>Struct</code> object, a method for retrieving

    51  * the SQL type name of the SQL structured type in the database, and methods

    52  * for retrieving its attribute values.

    53  *

    54  * <h3> Thread safety </h3>

    55  *

    56  * A SerialStruct is not safe for use by multiple concurrent threads.  If a

    57  * SerialStruct is to be used by more than one thread then access to the

    58  * SerialStruct should be controlled by appropriate synchronization.

    59  *

    60  * @since 1.5

    61  */

    62 public class SerialStruct implements Struct, Serializable, Cloneable {

    63 

    64 

    65     /**

    66      * The SQL type name for the structured type that this

    67      * <code>SerialStruct</code> object represents.  This is the name

    68      * used in the SQL definition of the SQL structured type.

    69      *

    70      * @serial

    71      */

    72     private String SQLTypeName;

    73 

    74     /**

    75      * An array of <code>Object</code> instances in  which each

    76      * element is an attribute of the SQL structured type that this

    77      * <code>SerialStruct</code> object represents.  The attributes are

    78      * ordered according to their order in the definition of the

    79      * SQL structured type.

    80      *

    81      * @serial

    82      */

    83     private Object attribs[];

    84 

    85     /**

    86      * Constructs a <code>SerialStruct</code> object from the given

    87      * <code>Struct</code> object, using the given <code>java.util.Map</code>

    88      * object for custom mapping the SQL structured type or any of its

    89      * attributes that are SQL structured types.

    90      *

    91      * @param in an instance of {@code Struct}

    92      * @param map a <code>java.util.Map</code> object in which

    93      *        each entry consists of 1) a <code>String</code> object

    94      *        giving the fully qualified name of a UDT and 2) the

    95      *        <code>Class</code> object for the <code>SQLData</code> implementation

    96      *        that defines how the UDT is to be mapped

    97      * @throws SerialException if an error occurs

    98      * @see java.sql.Struct

    99      */

   100      public SerialStruct(Struct in, Map<String,Class<?>> map)

   101          throws SerialException

   102      {

   103 

   104         try {

   105 

   106         // get the type name

   107         SQLTypeName = in.getSQLTypeName();

   108         System.out.println("SQLTypeName: " + SQLTypeName);

   109 

   110         // get the attributes of the struct

   111         attribs = in.getAttributes(map);

   112 

   113         /*

   114          * the array may contain further Structs

   115          * and/or classes that have been mapped,

   116          * other types that we have to serialize

   117          */

   118         mapToSerial(map);

   119 

   120         } catch (SQLException e) {

   121             throw new SerialException(e.getMessage());

   122         }

   123     }

   124 

   125      /**

   126       * Constructs a <code>SerialStruct</code> object from the

   127       * given <code>SQLData</code> object, using the given type

   128       * map to custom map it to a class in the Java programming

   129       * language.  The type map gives the SQL type and the class

   130       * to which it is mapped.  The <code>SQLData</code> object

   131       * defines the class to which the SQL type will be mapped.

   132       *

   133       * @param in an instance of the <code>SQLData</code> class

   134       *           that defines the mapping of the SQL structured

   135       *           type to one or more objects in the Java programming language

   136       * @param map a <code>java.util.Map</code> object in which

   137       *        each entry consists of 1) a <code>String</code> object

   138       *        giving the fully qualified name of a UDT and 2) the

   139       *        <code>Class</code> object for the <code>SQLData</code> implementation

   140       *        that defines how the UDT is to be mapped

   141       * @throws SerialException if an error occurs

   142       */

   143     public SerialStruct(SQLData in, Map<String,Class<?>> map)

   144         throws SerialException

   145     {

   146 

   147         try {

   148 

   149         //set the type name

   150         SQLTypeName = in.getSQLTypeName();

   151 

   152         Vector<Object> tmp = new Vector<>();

   153         in.writeSQL(new SQLOutputImpl(tmp, map));

   154         attribs = tmp.toArray();

   155 

   156         } catch (SQLException e) {

   157             throw new SerialException(e.getMessage());

   158         }

   159     }

   160 

   161 

   162     /**

   163      * Retrieves the SQL type name for this <code>SerialStruct</code>

   164      * object. This is the name used in the SQL definition of the

   165      * structured type

   166      *

   167      * @return a <code>String</code> object representing the SQL

   168      *         type name for the SQL structured type that this

   169      *         <code>SerialStruct</code> object represents

   170      * @throws SerialException if an error occurs

   171      */

   172     public String getSQLTypeName() throws SerialException {

   173         return SQLTypeName;

   174     }

   175 

   176     /**

   177      * Retrieves an array of <code>Object</code> values containing the

   178      * attributes of the SQL structured type that this

   179      * <code>SerialStruct</code> object represents.

   180      *

   181      * @return an array of <code>Object</code> values, with each

   182      *         element being an attribute of the SQL structured type

   183      *         that this <code>SerialStruct</code> object represents

   184      * @throws SerialException if an error occurs

   185      */

   186     public Object[]  getAttributes() throws SerialException {

   187         Object[] val = this.attribs;

   188         return (val == null) ? null : Arrays.copyOf(val, val.length);

   189     }

   190 

   191     /**

   192      * Retrieves the attributes for the SQL structured type that

   193      * this <code>SerialStruct</code> represents as an array of

   194      * <code>Object</code> values, using the given type map for

   195      * custom mapping if appropriate.

   196      *

   197      * @param map a <code>java.util.Map</code> object in which

   198      *        each entry consists of 1) a <code>String</code> object

   199      *        giving the fully qualified name of a UDT and 2) the

   200      *        <code>Class</code> object for the <code>SQLData</code> implementation

   201      *        that defines how the UDT is to be mapped

   202      * @return an array of <code>Object</code> values, with each

   203      *         element being an attribute of the SQL structured

   204      *         type that this <code>SerialStruct</code> object

   205      *         represents

   206      * @throws SerialException if an error occurs

   207      */

   208     public Object[] getAttributes(Map<String,Class<?>> map)

   209         throws SerialException

   210     {

   211         Object[] val = this.attribs;

   212         return (val == null) ? null : Arrays.copyOf(val, val.length);

   213     }

   214 

   215 

   216     /**

   217      * Maps attributes of an SQL structured type that are not

   218      * serialized to a serialized form, using the given type map

   219      * for custom mapping when appropriate.  The following types

   220      * in the Java programming language are mapped to their

   221      * serialized forms:  <code>Struct</code>, <code>SQLData</code>,

   222      * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, and

   223      * <code>Array</code>.

   224      * <P>

   225      * This method is called internally and is not used by an

   226      * application programmer.

   227      *

   228      * @param map a <code>java.util.Map</code> object in which

   229      *        each entry consists of 1) a <code>String</code> object

   230      *        giving the fully qualified name of a UDT and 2) the

   231      *        <code>Class</code> object for the <code>SQLData</code> implementation

   232      *        that defines how the UDT is to be mapped

   233      * @throws SerialException if an error occurs

   234      */

   235     private void mapToSerial(Map<String,Class<?>> map) throws SerialException {

   236 

   237         try {

   238 

   239         for (int i = 0; i < attribs.length; i++) {

   240             if (attribs[i] instanceof Struct) {

   241                 attribs[i] = new SerialStruct((Struct)attribs[i], map);

   242             } else if (attribs[i] instanceof SQLData) {

   243                 attribs[i] = new SerialStruct((SQLData)attribs[i], map);

   244             } else if (attribs[i] instanceof Blob) {

   245                 attribs[i] = new SerialBlob((Blob)attribs[i]);

   246             } else if (attribs[i] instanceof Clob) {

   247                 attribs[i] = new SerialClob((Clob)attribs[i]);

   248             } else if (attribs[i] instanceof Ref) {

   249                 attribs[i] = new SerialRef((Ref)attribs[i]);

   250             } else if (attribs[i] instanceof java.sql.Array) {

   251                 attribs[i] = new SerialArray((java.sql.Array)attribs[i], map);

   252             }

   253         }

   254 

   255         } catch (SQLException e) {

   256             throw new SerialException(e.getMessage());

   257         }

   258         return;

   259     }

   260 

   261     /**

   262      * Compares this SerialStruct to the specified object.  The result is

   263      * {@code true} if and only if the argument is not {@code null} and is a

   264      * {@code SerialStruct} object whose attributes are identical to this

   265      * object's attributes

   266      *

   267      * @param  obj The object to compare this {@code SerialStruct} against

   268      *

   269      * @return {@code true} if the given object represents a {@code SerialStruct}

   270      *          equivalent to this SerialStruct, {@code false} otherwise

   271      *

   272      */

   273     public boolean equals(Object obj) {

   274         if (this == obj) {

   275             return true;

   276         }

   277         if (obj instanceof SerialStruct) {

   278             SerialStruct ss = (SerialStruct)obj;

   279             return SQLTypeName.equals(ss.SQLTypeName) &&

   280                     Arrays.equals(attribs, ss.attribs);

   281         }

   282         return false;

   283     }

   284 

   285     /**

   286      * Returns a hash code for this {@code SerialStruct}. The hash code for a

   287      * {@code SerialStruct} object is computed using the hash codes

   288      * of the attributes of the {@code SerialStruct} object and its

   289      * {@code SQLTypeName}

   290      *

   291      * @return  a hash code value for this object.

   292      */

   293     public int hashCode() {

   294         return ((31 + Arrays.hashCode(attribs)) * 31) * 31

   295                 + SQLTypeName.hashCode();

   296     }

   297 

   298     /**

   299      * Returns a clone of this {@code SerialStruct}. The copy will contain a

   300      * reference to a clone of the underlying attribs array, not a reference

   301      * to the original underlying attribs array of this {@code SerialStruct} object.

   302      *

   303      * @return  a clone of this SerialStruct

   304      */

   305     public Object clone() {

   306         try {

   307             SerialStruct ss = (SerialStruct) super.clone();

   308             ss.attribs = Arrays.copyOf(attribs, attribs.length);

   309             return ss;

   310         } catch (CloneNotSupportedException ex) {

   311             // this shouldn't happen, since we are Cloneable

   312             throw new InternalError();

   313         }

   314 

   315     }

   316 

   317     /**

   318      * readObject is called to restore the state of the {@code SerialStruct} from

   319      * a stream.

   320      */

   321     private void readObject(ObjectInputStream s)

   322             throws IOException, ClassNotFoundException {

   323 

   324        ObjectInputStream.GetField fields = s.readFields();

   325        Object[] tmp = (Object[])fields.get("attribs", null);

   326        attribs = tmp == null ? null : tmp.clone();

   327        SQLTypeName = (String)fields.get("SQLTypeName", null);

   328     }

   329 

   330     /**

   331      * writeObject is called to save the state of the {@code SerialStruct}

   332      * to a stream.

   333      */

   334     private void writeObject(ObjectOutputStream s)

   335             throws IOException, ClassNotFoundException {

   336 

   337         ObjectOutputStream.PutField fields = s.putFields();

   338         fields.put("attribs", attribs);

   339         fields.put("SQLTypeName", SQLTypeName);

   340         s.writeFields();

   341     }

   342 

   343     /**

   344      * The identifier that assists in the serialization of this

   345      * <code>SerialStruct</code> object.

   346      */

   347     static final long serialVersionUID = -8322445504027483372L;

   348 }