| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xalan" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, Lotus |
| * Development Corporation., http://www.lotus.com. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.xalan.lib.sql; |
| |
| import org.w3c.dom.Element; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Attr; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.DOMException; |
| |
| import java.sql.ResultSet; |
| import java.sql.ResultSetMetaData; |
| import java.sql.SQLException; |
| import java.sql.ResultSet; |
| |
| import org.apache.xalan.res.XSLTErrorResources; |
| |
| /** |
| * <meta name="usage" content="experimental"/> |
| * Represents a column attribute on a column-header element. |
| * Each column-header element can contain any of the following |
| * attributes, depending on the ResultSetMetadata object returned with |
| * the query result set. |
| * <ul> |
| * <li>column-label</li> |
| * <li>column-name</li> |
| * <li>column-display-size</li> |
| * <li>column-type</li> |
| * <li>column-type-name</li> |
| * <li>precision</li> |
| * <li>scale</li> |
| * <li>catalogue-name</li> |
| * <li>schema-name</li> |
| * <li>table-name</li> |
| * <li>case-sensitive</li> |
| * <li>definitely-writable</li> |
| * <li>nullable</li> |
| * <li>signed</li> |
| * <li>writable</li> |
| * <li>searchable</li> |
| * </ul> |
| * @see org.apache.xalan.lib.sql.ColumnHeader |
| */ |
| public class ColumnAttribute extends StreamableNode implements Attr |
| { |
| |
| /** Column owning this attribute */ |
| Element m_owner; |
| |
| /** Meta data (column header) */ |
| ResultSetMetaData m_metadata; |
| |
| /** Attribute name */ |
| String m_name; |
| |
| /** Attribute type */ |
| int m_type; |
| |
| /** Owner Column index */ |
| int m_columnIndex; |
| |
| /** Column attribute */ |
| ColumnAttribute m_columnAttr; |
| |
| /** Constant for ISTRUE */ |
| static final String S_ISTRUE = "true"; |
| |
| /** Constant for ISFALSE */ |
| static final String S_ISFALSE = "false"; |
| |
| /** Constant for CATALOGUE_NAME */ |
| public static final int CATALOGUE_NAME = 0; |
| |
| /** Constnat for DISPLAY_SIZE */ |
| public static final int DISPLAY_SIZE = 1; |
| |
| /** Constant for COLUMN_LABEL */ |
| public static final int COLUMN_LABEL = 2; |
| |
| /** Constant for COLUMN_NAME */ |
| public static final int COLUMN_NAME = 3; |
| |
| /** Constant for COLUMN_TYPE */ |
| public static final int COLUMN_TYPE = 4; |
| |
| /** Constant for COLUMN_TYPENAME */ |
| public static final int COLUMN_TYPENAME = 5; |
| |
| /** Constant for PRECISION */ |
| public static final int PRECISION = 6; |
| |
| /** Constant for SCALE */ |
| public static final int SCALE = 7; |
| |
| /** Constant for SCHEMA_NAME */ |
| public static final int SCHEMA_NAME = 8; |
| |
| /** Constant for TABLE_NAME */ |
| public static final int TABLE_NAME = 9; |
| |
| /** Constant for CASESENSITIVE */ |
| public static final int CASESENSITIVE = 10; |
| |
| /** Constant for DEFINATELYWRITABLE */ |
| public static final int DEFINATELYWRITABLE = 11; |
| |
| /** Constant for ISNULLABLE */ |
| public static final int ISNULLABLE = 12; |
| |
| /** Constant for ISSIGNED */ |
| public static final int ISSIGNED = 13; |
| |
| /** Constant for ISWRITEABLE */ |
| public static final int ISWRITEABLE = 14; |
| |
| /** Constant for ISSEARCHABLE */ |
| public static final int ISSEARCHABLE = 15; |
| |
| /** Constant for NUMBER_ATTRIBUTES */ |
| public static final int NUMBER_ATTRIBUTES = 16; |
| |
| /** Constant for S_CATALOGUE_NAME */ |
| public static final String S_CATALOGUE_NAME = "catalogue-name"; |
| |
| /** Constant for S_DISPLAY_SIZE */ |
| public static final String S_DISPLAY_SIZE = "column-display-size"; |
| |
| /** Constant for S_COLUMN_LABEL */ |
| public static final String S_COLUMN_LABEL = "column-label"; |
| |
| /** Constant for S_COLUMN_NAME */ |
| public static final String S_COLUMN_NAME = "column-name"; |
| |
| /** Constant for S_COLUMN_TYPE */ |
| public static final String S_COLUMN_TYPE = "column-type"; |
| |
| /** Constant for S_COLUMN_TYPENAME */ |
| public static final String S_COLUMN_TYPENAME = "column-type-name"; |
| |
| /** Constant for S_PRECISION */ |
| public static final String S_PRECISION = "precision"; |
| |
| /** Constant for S_SCALE */ |
| public static final String S_SCALE = "scale"; |
| |
| /** Constant for S_SCHEMA_NAME */ |
| public static final String S_SCHEMA_NAME = "schema-name"; |
| |
| /** Constant for S_TABLE_NAME */ |
| public static final String S_TABLE_NAME = "table-name"; |
| |
| /** Constant for S_CASESENSITIVE */ |
| public static final String S_CASESENSITIVE = "case-sensitive"; |
| |
| /** Constant for S_DEFINATELYWRITABLE */ |
| public static final String S_DEFINATELYWRITABLE = "definitely-writable"; |
| |
| /** Constant for S_ISNULLABLE */ |
| public static final String S_ISNULLABLE = "nullable"; |
| |
| /** Constant for S_ISSIGNED */ |
| public static final String S_ISSIGNED = "signed"; |
| |
| /** Constant for S_ISWRITEABLE */ |
| public static final String S_ISWRITEABLE = "writable"; |
| |
| /** Constant for S_ISSEARCHABLE */ |
| public static final String S_ISSEARCHABLE = "searchable"; |
| |
| /** Table of column attribute names */ |
| static java.util.Hashtable m_namelookup = new java.util.Hashtable(); |
| |
| static |
| { |
| m_namelookup.put(S_CATALOGUE_NAME, new Integer(CATALOGUE_NAME)); |
| m_namelookup.put(S_DISPLAY_SIZE, new Integer(DISPLAY_SIZE)); |
| m_namelookup.put(S_COLUMN_LABEL, new Integer(COLUMN_LABEL)); |
| m_namelookup.put(S_COLUMN_NAME, new Integer(COLUMN_NAME)); |
| m_namelookup.put(S_COLUMN_TYPE, new Integer(COLUMN_TYPE)); |
| m_namelookup.put(S_COLUMN_TYPENAME, new Integer(COLUMN_TYPENAME)); |
| m_namelookup.put(S_PRECISION, new Integer(PRECISION)); |
| m_namelookup.put(S_SCALE, new Integer(SCALE)); |
| m_namelookup.put(S_SCHEMA_NAME, new Integer(SCHEMA_NAME)); |
| m_namelookup.put(S_TABLE_NAME, new Integer(TABLE_NAME)); |
| m_namelookup.put(S_CASESENSITIVE, new Integer(CASESENSITIVE)); |
| m_namelookup.put(S_DEFINATELYWRITABLE, new Integer(DEFINATELYWRITABLE)); |
| m_namelookup.put(S_ISNULLABLE, new Integer(ISNULLABLE)); |
| m_namelookup.put(S_ISSIGNED, new Integer(ISSIGNED)); |
| m_namelookup.put(S_ISWRITEABLE, new Integer(ISWRITEABLE)); |
| m_namelookup.put(S_ISSEARCHABLE, new Integer(ISSEARCHABLE)); |
| } |
| |
| /** |
| * Constructor ColumnAttribute |
| * |
| * |
| * @param statement Owning document |
| * @param owner Column owning this attribute |
| * @param columnIndex Owning column index |
| * @param type attribute type |
| * @param metadata Column header |
| */ |
| public ColumnAttribute(XStatement statement, Element owner, |
| int columnIndex, int type, |
| ResultSetMetaData metadata) |
| { |
| |
| super(statement); |
| |
| m_owner = owner; |
| m_metadata = metadata; |
| m_columnIndex = columnIndex; |
| m_type = type; |
| } |
| |
| /** |
| * Get column attribute name using constant value |
| * |
| * |
| * @param pos Constant value of attribute |
| * |
| * @return Attribute name corresponding to the given value |
| * or null if not found |
| */ |
| static String getAttrNameFromPos(int pos) |
| { |
| |
| switch (pos) |
| { |
| case CATALOGUE_NAME : |
| return S_CATALOGUE_NAME; |
| case DISPLAY_SIZE : |
| return S_DISPLAY_SIZE; |
| case COLUMN_LABEL : |
| return S_COLUMN_LABEL; |
| case COLUMN_NAME : |
| return S_COLUMN_NAME; |
| case COLUMN_TYPE : |
| return S_COLUMN_TYPE; |
| case COLUMN_TYPENAME : |
| return S_COLUMN_TYPENAME; |
| case PRECISION : |
| return S_PRECISION; |
| case SCALE : |
| return S_SCALE; |
| case SCHEMA_NAME : |
| return S_SCHEMA_NAME; |
| case TABLE_NAME : |
| return S_TABLE_NAME; |
| case CASESENSITIVE : |
| return S_CASESENSITIVE; |
| case DEFINATELYWRITABLE : |
| return S_DEFINATELYWRITABLE; |
| case ISNULLABLE : |
| return S_ISNULLABLE; |
| case ISSIGNED : |
| return S_ISSIGNED; |
| case ISWRITEABLE : |
| return S_ISWRITEABLE; |
| case ISSEARCHABLE : |
| return S_ISSEARCHABLE; |
| default : |
| return null; |
| } |
| } |
| |
| /** |
| * Get attribute constant value from name |
| * |
| * |
| * @param name Name of attribute |
| * |
| * @return Attribute value or -1 if not found |
| */ |
| static int getAttrPosFromName(String name) |
| { |
| |
| Integer intObj = (Integer) m_namelookup.get(name); |
| |
| if (null != intObj) |
| { |
| return intObj.intValue(); |
| } |
| else |
| return -1; |
| } |
| |
| /** |
| * Set column name |
| * |
| * |
| * @param name column attribute name |
| * |
| * @return True if the name is found in the lookup table |
| */ |
| public boolean setName(String name) |
| { |
| |
| m_name = name; |
| |
| int i = getAttrPosFromName(name); |
| |
| return (i >= 0); |
| } |
| |
| /** |
| * Get the column name |
| * |
| * |
| * @return the column name |
| */ |
| public String getNodeName() |
| { |
| return m_name; |
| } |
| |
| /** |
| * Get the column name |
| * |
| * |
| * @return the column name |
| */ |
| public String getName() |
| { |
| return m_name; |
| } |
| |
| /** |
| * Return Specified |
| * |
| * |
| * @return true |
| */ |
| public boolean getSpecified() |
| { |
| return true; |
| } |
| |
| /** |
| * Return column value |
| * |
| * |
| * @return column value |
| */ |
| public String getNodeValue() |
| { |
| return getValue(); |
| } |
| |
| /** |
| * Return column value |
| * |
| * |
| * @return column value |
| */ |
| public String getValue() |
| { |
| |
| int i = m_columnIndex + 1; // sql counts by 1 |
| |
| try |
| { |
| |
| // System.out.println("m_type: "+m_type); |
| switch (m_type) |
| { |
| case CATALOGUE_NAME : |
| return m_metadata.getCatalogName(i); |
| case DISPLAY_SIZE : |
| return Integer.toString(m_metadata.getColumnDisplaySize(i)); |
| case COLUMN_LABEL : |
| return m_metadata.getColumnLabel(i); |
| case COLUMN_NAME : |
| return m_metadata.getColumnName(i); |
| case COLUMN_TYPE : |
| return Integer.toString(m_metadata.getColumnType(i)); |
| case COLUMN_TYPENAME : |
| return m_metadata.getColumnTypeName(i); |
| case PRECISION : |
| return Integer.toString(m_metadata.getPrecision(i)); |
| case SCALE : |
| return Integer.toString(m_metadata.getScale(i)); |
| case SCHEMA_NAME : |
| return m_metadata.getSchemaName(i); |
| case TABLE_NAME : |
| return m_metadata.getTableName(i); |
| case CASESENSITIVE : |
| return m_metadata.isCaseSensitive(i) ? S_ISTRUE : S_ISFALSE; |
| case DEFINATELYWRITABLE : |
| return m_metadata.isDefinitelyWritable(i) ? S_ISTRUE : S_ISFALSE; |
| case ISNULLABLE : |
| return Integer.toString(m_metadata.isNullable(i)); |
| case ISSIGNED : |
| return m_metadata.isSigned(i) ? S_ISTRUE : S_ISFALSE; |
| case ISWRITEABLE : |
| return m_metadata.isWritable(i) ? S_ISTRUE : S_ISFALSE; |
| case ISSEARCHABLE : |
| return m_metadata.isSearchable(i) ? S_ISTRUE : S_ISFALSE; |
| default : |
| return ""; |
| } |
| } |
| catch (SQLException sqle) |
| { |
| return "SQL ERROR!"; |
| } |
| } |
| |
| /** |
| * setValue - Not supported |
| * |
| * |
| * @param value column value to set |
| * |
| * @throws DOMException |
| */ |
| public void setValue(String value) throws DOMException |
| { |
| error(XSLTErrorResources.ER_FUNCTION_NOT_SUPPORTED); |
| } |
| |
| /** |
| * Return column owner |
| * |
| * |
| * @return Column owner |
| */ |
| public Element getOwnerElement() |
| { |
| return m_owner; |
| } |
| |
| /** |
| * Get parent node |
| * |
| * |
| * @return null |
| */ |
| public Node getParentNode() |
| { |
| return null; |
| } |
| |
| /** |
| * Return Node.ATTRIBUTE_NODE. |
| * |
| * @return ATTRIBUTE_NODE type |
| */ |
| public short getNodeType() |
| { |
| return Node.ATTRIBUTE_NODE; |
| } |
| } |