Attachment #131302 for bug #156304

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 156304
Collapse All | Expand All

Lines 1-5 Link Here

(-)a/db.metadata.model/manifest.mf (-2 / +2 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.db.metadata.model/0	2	OpenIDE-Module: org.netbeans.modules.db.metadata.model/1
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/db/metadata/model/resources/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/db/metadata/model/resources/Bundle.properties
4	OpenIDE-Module-Specification-Version: 0.21	4	OpenIDE-Module-Specification-Version: 1.0
5	AutoUpdate-Show-In-Client: false	5	AutoUpdate-Show-In-Client: false




            throw new SQLException(t);
        }
    }

    /**
     * Call {@link DatabaseMetaData#geFunctions(String, String, String)},
     * wrapping any internal runtime exception into an {@link SQLException}.
     */
    public static ResultSet getFunctions(DatabaseMetaData dmd,
            String catalog, String schemaPattern, String functionNamePattern)
            throws SQLException {
        try {
            return dmd.getFunctions(catalog, schemaPattern,
                    functionNamePattern);
        } catch (SQLException e) {
            throw e;
        } catch (Throwable t) {
            throw new SQLException(t);
        }
    }
}




 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.modules.db.metadata.model.api;

import java.util.Collection;
import org.netbeans.modules.db.metadata.model.spi.FunctionImplementation;

/**
 *
 * @author Andrei Badea, Matthias42
 *
 * @since db.metadata.model/1.0
 */
public class Function extends Tuple {

    final FunctionImplementation impl;

    Function(FunctionImplementation impl) {
        this.impl = impl;
    }

    /**
     * Returns the schema containing this function.
     *
     * @return the parent schema.
     */

    }

    /**
     * Returns the return value of this function
     *
     * @return the return value for this function
     */
    public Value getReturnValue() {
        return impl.getReturnValue();
    }

    /**
     * Returns the columns in the result set for this function.
     *
     * @return the columns.
     * @throws MetadataException if an error occurs while retrieving the
     * metadata.
     */
    public Collection<Column> getColumns() {
        return impl.getColumns();

     * Returns the column with the given name.
     *
     * @param name a column name.
     * @return a column named {@code name} or {@code null} if there is no such
     * column.
     * @throws MetadataException if an error occurs while retrieving the
     * metadata.
     */
    public Column getColumn(String name) {
        return impl.getColumn(name);
    }

    /**
     * Returns the list of parameters for this function
     *
     * @return the list of parameters for this function
     * @throws MetadataException if an error occurs while retrieving the
     * metadata
     */
    public Collection<Parameter> getParameters() {
        return impl.getParameters();


    /**
     * Returns the parameter with the given name
     *
     * @throws MetadataException if an error occurs while retrieving the
     * metadata
     */
    public Parameter getParameter(String name) {
        return impl.getParameter(name);


    @Override
    public String toString() {
        return "Function[name='" + getName() + "']"; // NOI18N
    }
}

Lines 50-55 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/Metadata.java (+6 lines)
50	import org.netbeans.modules.db.metadata.model.spi.ColumnImplementation;	50	import org.netbeans.modules.db.metadata.model.spi.ColumnImplementation;
51	import org.netbeans.modules.db.metadata.model.spi.ForeignKeyColumnImplementation;	51	import org.netbeans.modules.db.metadata.model.spi.ForeignKeyColumnImplementation;
52	import org.netbeans.modules.db.metadata.model.spi.ForeignKeyImplementation;	52	import org.netbeans.modules.db.metadata.model.spi.ForeignKeyImplementation;
		53	import org.netbeans.modules.db.metadata.model.spi.FunctionImplementation;
53	import org.netbeans.modules.db.metadata.model.spi.IndexColumnImplementation;	54	import org.netbeans.modules.db.metadata.model.spi.IndexColumnImplementation;
54	import org.netbeans.modules.db.metadata.model.spi.IndexImplementation;	55	import org.netbeans.modules.db.metadata.model.spi.IndexImplementation;
55	import org.netbeans.modules.db.metadata.model.spi.MetadataImplementation;	56	import org.netbeans.modules.db.metadata.model.spi.MetadataImplementation;
Lines 170-175 Link Here
170	}	171	}
171		172
172	@Override	173	@Override
		174	public Function createFunction(FunctionImplementation impl) {
		175	return new Function(impl);
		176	}
		177
		178	@Override
173	public Parameter createParameter(ParameterImplementation impl) {	179	public Parameter createParameter(ParameterImplementation impl) {
174	return new Parameter(impl);	180	return new Parameter(impl);
175	}	181	}

Lines 75-80 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/MetadataElementHandle.java (-2 / +33 lines)
75	private static final int FOREIGN_KEY = 3;	75	private static final int FOREIGN_KEY = 3;
76	private static final int FOREIGN_KEY_COLUMN = 4;	76	private static final int FOREIGN_KEY_COLUMN = 4;
77	private static final int INDEX_COLUMN = 4;	77	private static final int INDEX_COLUMN = 4;
		78	private static final int FUNCTION = 2;
78		79
79	// The hierarchy of names for this element (e.g. ["mycatalog","myschema","mytable","mycolumn"])	80	// The hierarchy of names for this element (e.g. ["mycatalog","myschema","mytable","mycolumn"])
80	//	81	//
Lines 196-201 Link Here
196	return (T) resolveForeignKeyColumn(metadata);	197	return (T) resolveForeignKeyColumn(metadata);
197	case INDEX_COLUMN:	198	case INDEX_COLUMN:
198	return (T) resolveIndexColumn(metadata);	199	return (T) resolveIndexColumn(metadata);
		200	case RETURN_VALUE:
		201	return (T) resolveReturnValue(metadata);
		202	case FUNCTION:
		203	return (T) resolveFunction(metadata);
199	default:	204	default:
200	throw new IllegalStateException("Unhandled kind " + kinds[kinds.length -1]);	205	throw new IllegalStateException("Unhandled kind " + kinds[kinds.length -1]);
201	}	206	}
Lines 236-247 Link Here
236		241
237	private Procedure resolveProcedure(Metadata metadata) {	242	private Procedure resolveProcedure(Metadata metadata) {
238	Schema schema = resolveSchema(metadata);	243	Schema schema = resolveSchema(metadata);
239	if (schema != null) {	244	if (schema != null && kinds[PROCEDURE] == Kind.PROCEDURE) {
240	return schema.getProcedure(names[PROCEDURE]);	245	return schema.getProcedure(names[PROCEDURE]);
241	}	246	}
242	return null;	247	return null;
243	}	248	}
244		249
		250	private Function resolveFunction(Metadata metadata) {
		251	Schema schema = resolveSchema(metadata);
		252	if (schema != null && kinds[FUNCTION] == Kind.FUNCTION) {
		253	return schema.getFunction(names[FUNCTION]);
		254	}
		255	return null;
		256	}
		257
		258	private Value resolveReturnValue(Metadata metadata) {
		259	Function proc = resolveFunction(metadata);
		260	if (proc != null) {
		261	return proc.getReturnValue();
		262	}
		263	Procedure proc2 = resolveProcedure(metadata);
		264	if (proc2 != null) {
		265	return proc2.getReturnValue();
		266	}
		267	return null;
		268	}
		269
245	private PrimaryKey resolvePrimaryKey(Metadata metadata) {	270	private PrimaryKey resolvePrimaryKey(Metadata metadata) {
246	Table table = resolveTable(metadata);	271	Table table = resolveTable(metadata);
247	if (table != null) {	272	if (table != null) {
Lines 283-288 Link Here
283	if (proc != null) {	308	if (proc != null) {
284	return proc.getParameter(names[PARAMETER]);	309	return proc.getParameter(names[PARAMETER]);
285	}	310	}
		311	Function proc2 = resolveFunction(metadata);
		312	if (proc2 != null) {
		313	return proc2.getParameter(names[PARAMETER]);
		314	}
286	return null;	315	return null;
287	}	316	}
288		317
Lines 335-341 Link Here
335	FOREIGN_KEY(ForeignKey.class),	364	FOREIGN_KEY(ForeignKey.class),
336	INDEX(Index.class),	365	INDEX(Index.class),
337	FOREIGN_KEY_COLUMN(ForeignKeyColumn.class),	366	FOREIGN_KEY_COLUMN(ForeignKeyColumn.class),
338	INDEX_COLUMN(IndexColumn.class);	367	INDEX_COLUMN(IndexColumn.class),
		368	RETURN_VALUE(Value.class),
		369	FUNCTION(Function.class);
339		370
340	public static Kind of(MetadataElement element) {	371	public static Kind of(MetadataElement element) {
341	return of(element.getClass());	372	return of(element.getClass());

Lines 62-72 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/Parameter.java (-5 lines)
62	this.impl = impl;	62	this.impl = impl;
63	}	63	}
64		64
65	@Override
66	public Procedure getParent() {
67	return impl.getParent();
68	}
69
70	public Direction getDirection() {	65	public Direction getDirection() {
71	return impl.getDirection();	66	return impl.getDirection();
72	}	67	}

Lines 58-64 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/Procedure.java (-2 / +2 lines)
58	}	58	}
59		59
60	/**	60	/**
61	* Returns the schema containing this table.	61	* Returns the schema containing this procedure.
62	*	62	*
63	* @return the parent schema.	63	* @return the parent schema.
64	*/	64	*/
Lines 132-137 Link Here
132		132
133	@Override	133	@Override
134	public String toString() {	134	public String toString() {
135	return "View[name='" + getName() + "']"; // NOI18N	135	return "Procedure[name='" + getName() + "']"; // NOI18N
136	}	136	}
137	}	137	}




    }

    /**
     * Get the list of procedures for this schema
     *
     * @return the procedures
     * @throws MetadataException if an error occurs while retrieving the metadata

    }

    /**
     * Get the list of functions for this schema
     *
     * @return the functions
     * @throws MetadataException if an error occurs while retrieving the
     * metadata
     * @since db.metadata.model/1.0
     */
    public Collection<Function> getFunctions() {
        return impl.getFunctions();
    }

    /**
     * Return a function with the given name
     *
     * @param name a function name
     * @return a function named {@code name} or {@code null} if there is no such
     * function.
     * @throws MetadataException if an error occurs while retrieving the
     * metadata
     * @since db.metadata.model/1.0
     */
    public Function getFunction(String name) {
        return impl.getFunction(name);
    }

    /**
     * Refresh the metadata for this schema
     */
    public void refresh() {




 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.modules.db.metadata.model.jdbc;

import java.sql.DatabaseMetaData;

import org.netbeans.modules.db.metadata.model.api.Column;
import org.netbeans.modules.db.metadata.model.api.MetadataException;
import org.netbeans.modules.db.metadata.model.api.Parameter;
import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
import org.netbeans.modules.db.metadata.model.api.Schema;
import org.netbeans.modules.db.metadata.model.api.Value;
import org.netbeans.modules.db.metadata.model.spi.FunctionImplementation;

/**
 *
 * @author David Van Couvering
 */
public class JDBCFunction extends FunctionImplementation {

    private static final Logger LOGGER = Logger.getLogger(JDBCFunction.class.getName());

    private final JDBCSchema jdbcSchema;
    private final String name;

    private Map<String, Column> columns;
    private Map<String, Parameter> parameters;
    private Value returnValue;

    public JDBCFunction(JDBCSchema jdbcSchema, String name) {
        this.jdbcSchema = jdbcSchema;
        this.name = name;
    }


    @Override
    public String toString() {
        return "JDBCFunction[name='" + name + "']"; // NOI18N
    }

    protected JDBCColumn createJDBCColumn(int position, ResultSet rs) throws SQLException {
        return new JDBCColumn(this.getFunction(), position, JDBCValue.createFunctionValue(rs, this.getFunction()));
    }

    protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {
        Parameter.Direction direction = JDBCUtils.getFunctionDirection(rs.getShort("COLUMN_TYPE"));
        return new JDBCParameter(this.getFunction(), JDBCValue.createFunctionValue(rs, this.getFunction()), direction, position);
    }

    protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {
        return JDBCValue.createFunctionValue(rs, this.getFunction());
    }

    protected void createProcedureInfo() {
        LOGGER.log(Level.FINE, "Initializing procedure info in " + this);

        Map<String, Column> newColumns = new LinkedHashMap<String, Column>();
        Map<String, Parameter> newParams = new LinkedHashMap<String, Parameter>();
        int resultCount = 0;
        int paramCount = 0;

        try {
            ResultSet rs = jdbcSchema.getJDBCCatalog().getJDBCMetadata().getDmd().getFunctionColumns(jdbcSchema.getJDBCCatalog().getName(), jdbcSchema.getName(), name, "%"); // NOI18N
            try {
                while (rs.next()) {
                    short columnType = rs.getShort("COLUMN_TYPE");
                    switch (columnType) {
                        case DatabaseMetaData.functionColumnResult:
                            addColumn(++resultCount, rs, newColumns);
                            break;
                        case DatabaseMetaData.functionColumnIn:
                        case DatabaseMetaData.functionColumnInOut:
                        case DatabaseMetaData.functionColumnOut:
                        case DatabaseMetaData.functionColumnUnknown:
                            addParameter(++paramCount, rs, newParams);
                            break;
                        case DatabaseMetaData.functionReturn:
                            setReturnValue(rs);
                            break;
                        default:

        parameters = Collections.unmodifiableMap(newParams);
    }

    private void addColumn(int position, ResultSet rs, Map<String, Column> newColumns) throws SQLException {
        Column column = createJDBCColumn(position, rs).getColumn();
        newColumns.put(column.getName(), column);
        LOGGER.log(Level.FINE, "Created column {0}", column);
    }

    private void addParameter(int position, ResultSet rs, Map<String, Parameter> newParams) throws SQLException {
        Parameter param = createJDBCParameter(position, rs).getParameter();
        newParams.put(param.getName(), param);
        LOGGER.log(Level.FINE, "Created parameter {0}", param);
    }




import java.util.logging.Logger;
import org.netbeans.modules.db.metadata.model.api.Nullable;
import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
import org.netbeans.modules.db.metadata.model.api.MetadataElement;
import org.netbeans.modules.db.metadata.model.api.SQLType;
import org.netbeans.modules.db.metadata.model.spi.ParameterImplementation;


public class JDBCParameter extends ParameterImplementation {

    private static final Logger LOGGER = Logger.getLogger(JDBCParameter.class.getName());
    private final MetadataElement parent;
    private final Direction direction;
    private final int ordinalPosition;
    private final JDBCValue value;

    public JDBCParameter(MetadataElement parent, JDBCValue value, Direction direction, int ordinalPosition) {
        this.parent = parent;
        this.direction = direction;
        this.value = value;
        this.ordinalPosition = ordinalPosition;

    }

    @Override
    public MetadataElement getParent() {
        return parent;
    }

    @Override




    }

    protected JDBCColumn createJDBCColumn(int position, ResultSet rs) throws SQLException {
        return new JDBCColumn(this.getProcedure(), position, JDBCValue.createProcedureValue(rs, this.getProcedure()));
    }

    protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {
        Direction direction = JDBCUtils.getProcedureDirection(rs.getShort("COLUMN_TYPE")); //NOI18N
        return new JDBCParameter(this.getProcedure(), JDBCValue.createProcedureValue(rs, this.getProcedure()), direction, position);
    }

    protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {
        return JDBCValue.createProcedureValue(rs, this.getProcedure());
    }

    protected void createProcedureInfo() {

Lines 70-75 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCSchema.java (+48 lines)
70	protected Map<String, Table> tables;	70	protected Map<String, Table> tables;
71	protected Map<String, View> views;	71	protected Map<String, View> views;
72	protected Map<String, Procedure> procedures;	72	protected Map<String, Procedure> procedures;
		73	protected Map<String, Function> functions;
73		74
74	public JDBCSchema(JDBCCatalog jdbcCatalog, String name, boolean _default, boolean synthetic) {	75	public JDBCSchema(JDBCCatalog jdbcCatalog, String name, boolean _default, boolean synthetic) {
75	this.jdbcCatalog = jdbcCatalog;	76	this.jdbcCatalog = jdbcCatalog;
Lines 129-134 Link Here
129	}	130	}
130		131
131	@Override	132	@Override
		133	public Function getFunction(String name) {
		134	return initFunctions().get(name);
		135	}
		136
		137	@Override
		138	public Collection<Function> getFunctions() {
		139	return initFunctions().values();
		140	}
		141
		142	@Override
132	public void refresh() {	143	public void refresh() {
133	tables = null;	144	tables = null;
134	views = null;	145	views = null;
Lines 148-153 Link Here
148	return new JDBCProcedure(this, procedureName);	159	return new JDBCProcedure(this, procedureName);
149	}	160	}
150		161
		162	protected JDBCFunction createJDBCFunction(String functionName) {
		163	return new JDBCFunction(this, functionName);
		164	}
		165
151	protected JDBCView createJDBCView(String viewName) {	166	protected JDBCView createJDBCView(String viewName) {
152	return new JDBCView(this, viewName);	167	return new JDBCView(this, viewName);
153	}	168	}
Lines 224-229 Link Here
224	procedures = Collections.unmodifiableMap(newProcedures);	239	procedures = Collections.unmodifiableMap(newProcedures);
225	}	240	}
226		241
		242	protected void createFunctions() {
		243	LOGGER.log(Level.FINE, "Initializing functions in {0}", this); //NOI18N
		244	Map<String, Function> newProcedures = new LinkedHashMap<String, Function>();
		245	try {
		246	ResultSet rs = MetadataUtilities.getFunctions(jdbcCatalog.getJDBCMetadata().getDmd(),
		247	jdbcCatalog.getName(), name, "%"); // NOI18N
		248	try {
		249	while (rs.next()) {
		250	String functionName = MetadataUtilities.trimmed(rs.getString("FUNCTION_NAME")); // NOI18N
		251	Function function = createJDBCFunction(functionName).getFunction();
		252	newProcedures.put(functionName, function);
		253	LOGGER.log(Level.FINE, "Created function {0}", function); //NOI18N
		254	}
		255	} finally {
		256	if (rs != null) {
		257	rs.close();
		258	}
		259	}
		260	} catch (SQLException e) {
		261	throw new MetadataException(e);
		262	}
		263	functions = Collections.unmodifiableMap(newProcedures);
		264	}
		265
227	private Map<String, Table> initTables() {	266	private Map<String, Table> initTables() {
228	if (tables != null) {	267	if (tables != null) {
229	return tables;	268	return tables;
Lines 252-255 Link Here
252	createProcedures();	291	createProcedures();
253	return procedures;	292	return procedures;
254	}	293	}
		294
		295	private Map<String, Function> initFunctions() {
		296	if (functions != null) {
		297	return functions;
		298	}
		299
		300	createFunctions();
		301	return functions;
		302	}
255	}	303	}

Lines 142-151 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCTable.java (-2 / +2 lines)
142	int position = 0;	142	int position = 0;
143	JDBCValue jdbcValue;	143	JDBCValue jdbcValue;
144	if (isOdbc(rs)) {	144	if (isOdbc(rs)) {
145	jdbcValue = JDBCValue.createTableColumnValueODBC(rs);	145	jdbcValue = JDBCValue.createTableColumnValueODBC(rs, this.getTable());
146	} else {	146	} else {
147	position = rs.getInt("ORDINAL_POSITION");	147	position = rs.getInt("ORDINAL_POSITION");
148	jdbcValue = JDBCValue.createTableColumnValue(rs);	148	jdbcValue = JDBCValue.createTableColumnValue(rs, this.getTable());
149	}	149	}
150	return new JDBCColumn(this.getTable(), position, jdbcValue);	150	return new JDBCColumn(this.getTable(), position, jdbcValue);
151	}	151	}




        }
    }
    
    public static Direction getProcedureDirection(short sqlDirection) {
        switch (sqlDirection) {
            case DatabaseMetaData.procedureColumnOut:
                return Direction.OUT;

            case DatabaseMetaData.procedureColumnIn:
                return Direction.IN;
            default:
                LOGGER.log(Level.INFO, "Unknown direction value from DatabaseMetadata.getProcedureColumns(): " + sqlDirection);
                return Direction.IN;
        }
    }

    public static Direction getFunctionDirection(short sqlDirection) {
        switch (sqlDirection) {
            case DatabaseMetaData.functionColumnOut:
                return Direction.OUT;
            case DatabaseMetaData.functionColumnInOut:
                return Direction.INOUT;
            case DatabaseMetaData.functionColumnIn:
                return Direction.IN;
            default:
                LOGGER.log(Level.INFO, "Unknown direction value from DatabaseMetadata.getFunctionColumns(): " + sqlDirection);
                return Direction.IN;
        }
    }





    private static final Logger LOGGER = Logger.getLogger(JDBCValue.class.getName());

    private final MetadataElement parent;
    private final String name;
    private final SQLType type;
    private final int length;

     * @return a newly created JDBCValue instance
     * @throws java.sql.SQLException
     */
    public static JDBCValue createProcedureValue(ResultSet rs, MetadataElement parent) throws SQLException {
        String name = MetadataUtilities.trimmed(rs.getString("COLUMN_NAME"));
        SQLType type = JDBCUtils.getSQLType(rs.getInt("DATA_TYPE"));
        int length = rs.getInt("LENGTH");

        short radix = rs.getShort("RADIX");
        Nullable nullable = JDBCUtils.getProcedureNullable(rs.getShort("NULLABLE"));

        return new JDBCValue(parent, name, type, length, precision, radix, scale, nullable);
    }

    /**
     * Create a value from a row in getFunctionColumns()
     *
     * @param rs the result set from getFunctionColumns, assumed to be at a
     * valid row
     * @return a newly created JDBCValue instance
     * @throws java.sql.SQLException
     */
    public static JDBCValue createFunctionValue(ResultSet rs, MetadataElement parent) throws SQLException {
        // Delegate to the procedure Version - currently the same columns are used
        return createProcedureValue(rs, parent);
    }

    /**

     * @return a newly created JDBCValue instance
     * @throws java.sql.SQLException
     */
    public static JDBCValue createTableColumnValue(ResultSet rs, MetadataElement parent) throws SQLException {
        String name = MetadataUtilities.trimmed(rs.getString("COLUMN_NAME"));
        SQLType type = JDBCUtils.getSQLType(rs.getInt("DATA_TYPE"));


        short radix = rs.getShort("NUM_PREC_RADIX");
        Nullable nullable = JDBCUtils.getColumnNullable(rs.getShort("NULLABLE"));

        return new JDBCValue(parent, name, type, length, precision, radix, scale, nullable);
    }

    /**

     * @return a newly created JDBCValue instance
     * @throws java.sql.SQLException
     */
    public static JDBCValue createTableColumnValueODBC(ResultSet rs, MetadataElement parent) throws SQLException {
        String name = MetadataUtilities.trimmed(rs.getString("COLUMN_NAME"));
        SQLType type = JDBCUtils.getSQLType(rs.getInt("DATA_TYPE"));
        int length = 0;

        short radix = rs.getShort("RADIX");
        Nullable nullable = JDBCUtils.getColumnNullable(rs.getShort("NULLABLE"));

        return new JDBCValue(parent, name, type, length, precision, radix, scale, nullable);
    }

    public JDBCValue(MetadataElement parent, String name, SQLType type, int length, int precision, short radix, short scale, Nullable nullable) {
        this.parent = parent;
        this.name = name;
        this.type = type;
        this.length = length;


    @Override
    public MetadataElement getParent() {
        return this.parent;
    }

}

Lines 99-105 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCView.java (-1 / +1 lines)
99		99
100	protected JDBCColumn createJDBCColumn(ResultSet rs) throws SQLException {	100	protected JDBCColumn createJDBCColumn(ResultSet rs) throws SQLException {
101	int ordinalPosition = rs.getInt("ORDINAL_POSITION");	101	int ordinalPosition = rs.getInt("ORDINAL_POSITION");
102	return new JDBCColumn(this.getView(), ordinalPosition, JDBCValue.createTableColumnValue(rs));	102	return new JDBCColumn(this.getView(), ordinalPosition, JDBCValue.createTableColumnValue(rs, this.getView()));
103	}	103	}
104		104
105	protected void createColumns() {	105	protected void createColumns() {





import java.sql.ResultSet;
import java.sql.SQLException;
import org.netbeans.modules.db.metadata.model.api.MetadataElement;
import org.netbeans.modules.db.metadata.model.api.Nullable;
import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
import org.netbeans.modules.db.metadata.model.api.SQLType;


    @Override
    protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {
        Direction direction = JDBCUtils.getProcedureDirection(rs.getShort("COLUMN_TYPE"));
        return new JDBCParameter(this.getProcedure(), createValue(rs, this.getProcedure()), direction, position);
    }

    @Override
    protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {
        return createValue(rs, this.getProcedure());
    }

    @Override

     * Logged as a MySQL bug - http://bugs.mysql.com/bug.php?id=41269
     * When this is fixed this workaround will need to be backed out.
     */
    private static JDBCValue createValue(ResultSet rs, MetadataElement parent) throws SQLException {
        String name = rs.getString("COLUMN_NAME");

        int length = 0;

        short radix = rs.getShort("RADIX");
        Nullable nullable = JDBCUtils.getProcedureNullable(rs.getShort("NULLABLE"));

        return new JDBCValue(parent, name, type, length, precision, radix, scale, nullable);
    }






 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */

package org.netbeans.modules.db.metadata.model.spi;

import java.util.Collection;
import org.netbeans.modules.db.metadata.model.MetadataAccessor;
import org.netbeans.modules.db.metadata.model.api.Column;
import org.netbeans.modules.db.metadata.model.api.Function;
import org.netbeans.modules.db.metadata.model.api.Parameter;
import org.netbeans.modules.db.metadata.model.api.Procedure;
import org.netbeans.modules.db.metadata.model.api.Schema;
import org.netbeans.modules.db.metadata.model.api.Value;

/**
 *
 * @author Andrei Badea, Matthias42
 * @since db.metadata.model/1.0
 */
public abstract class FunctionImplementation {

    private Function table;

    public final Function getFunction() {
        if (table == null) {
            table = MetadataAccessor.getDefault().createFunction(this);
        }
        return table;
    }

Lines 45-51 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/spi/ParameterImplementation.java (-3 lines)
45	import org.netbeans.modules.db.metadata.model.MetadataAccessor;	45	import org.netbeans.modules.db.metadata.model.MetadataAccessor;
46	import org.netbeans.modules.db.metadata.model.api.Parameter;	46	import org.netbeans.modules.db.metadata.model.api.Parameter;
47	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;	47	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
48	import org.netbeans.modules.db.metadata.model.api.Procedure;
49		48
50	/**	49	/**
51	*	50	*
Lines 64-71 Link Here
64		63
65	public abstract Direction getDirection();	64	public abstract Direction getDirection();
66		65
67	public abstract Procedure getParent();
68
69	public abstract int getOrdinalPosition();	66	public abstract int getOrdinalPosition();
70		67
71	}	68	}




package org.netbeans.modules.db.metadata.model.spi;

import java.util.Collection;
import java.util.Collections;
import org.netbeans.modules.db.metadata.model.MetadataAccessor;
import org.netbeans.modules.db.metadata.model.api.Catalog;
import org.netbeans.modules.db.metadata.model.api.Function;
import org.netbeans.modules.db.metadata.model.api.Procedure;
import org.netbeans.modules.db.metadata.model.api.Schema;
import org.netbeans.modules.db.metadata.model.api.Table;


    public abstract Collection<Procedure> getProcedures();

    /**
     * @since db.metadata.model/1.0
     */
    public Function getFunction(String name) {
        return null;
    }

    /**
     * @since db.metadata.model/1.0
     */
    public Collection<Function> getFunctions() {
        return Collections.emptyList();
    }

    public abstract boolean isDefault();

    public abstract boolean isSynthetic();





import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import org.netbeans.modules.db.metadata.model.api.MetadataElementHandle.Kind;
import org.netbeans.modules.db.metadata.model.jdbc.JDBCMetadata;

        stmt.executeUpdate("CREATE TABLE BAR (ID INT NOT NULL PRIMARY KEY, FOO_ID INT NOT NULL, FOREIGN KEY (FOO_ID) REFERENCES FOO)");
        stmt.executeUpdate("CREATE INDEX FOO_INDEX ON FOO(FOO)");
        stmt.executeUpdate("CREATE VIEW FOOVIEW AS SELECT * FROM FOO");
        stmt.executeUpdate("CREATE PROCEDURE XY (IN S_MONTH INTEGER, IN S_DAYS VARCHAR(255)) "
                + " DYNAMIC RESULT SETS 1 "
                + " PARAMETER STYLE JAVA READS SQL  DATA LANGUAGE JAVA "
                + " EXTERNAL NAME 'org.netbeans.modules.db.metadata.model.api.MetadataElementHandleTest.demoProcedure'");
        stmt.executeUpdate("CREATE FUNCTION TO_DEGREES(RADIANS DOUBLE) RETURNS DOUBLE "
                + "PARAMETER STYLE JAVA NO SQL LANGUAGE JAVA "
                + "EXTERNAL NAME 'java.lang.Math.toDegrees'");
        stmt.close();
        metadata = new JDBCMetadata(conn, "APP").getMetadata();
    }

    public void testResolve() throws SQLException {
        Catalog catalog = metadata.getDefaultCatalog();
        MetadataElementHandle<Catalog> catalogHandle = MetadataElementHandle.create(catalog);
            Catalog resolvedCatalog = catalogHandle.resolve(metadata);

        View resolvedView = viewHandle.resolve(metadata);
        assertSame(view, resolvedView);

        Function function = schema.getFunction("TO_DEGREES");
        MetadataElementHandle<Function> procedureHandle = MetadataElementHandle.create(function);
        Function resolvedFunction = procedureHandle.resolve(metadata);
        assertSame(function, resolvedFunction);

        assertTrue(function.getParameters().size() > 0);

        for (Parameter param : function.getParameters()) {
            MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(param);
            Parameter resolvedParam = paramHandle.resolve(metadata);
            assertSame(param, resolvedParam);
        }

        Value value = function.getReturnValue();
        assertNotNull(value);
        MetadataElementHandle<Value> valueHandle = MetadataElementHandle.create(value);
        Value resolvedValue = valueHandle.resolve(metadata);
        assertSame(value, resolvedValue);

        Procedure procedure = schema.getProcedure("XY");
        MetadataElementHandle<Procedure> functionHandle = MetadataElementHandle.create(procedure);
        Procedure resolvedProcedure = functionHandle.resolve(metadata);
        assertSame(procedure, resolvedProcedure);

        assertTrue(procedure.getParameters().size() > 0);

        for (Parameter param : procedure.getParameters()) {
            MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(param);
            Parameter resolvedParam = paramHandle.resolve(metadata);
            assertSame(param, resolvedParam);
        }

        value = procedure.getReturnValue();
        assertNull(value);

        // Ensure conflicting names of functions and procudures don't spill over
        // a MetadataElementHandle<Parameter> from a procedure must not be
        // resolvable against a function with the same "path" (Function name =
        // procedure name and same parameter name)
        procedure = schema.getProcedure("XY");
        MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(procedure.getParameters().iterator().next());
        assertNotNull(paramHandle.resolve(metadata));

        Statement stmt = conn.createStatement();
        stmt.executeUpdate("DROP PROCEDURE XY");
        stmt.executeUpdate("CREATE FUNCTION XY (S_MONTH INTEGER, S_DAYS VARCHAR(255)) RETURNS DOUBLE "
                + " PARAMETER STYLE JAVA READS SQL  DATA LANGUAGE JAVA "
                + " EXTERNAL NAME 'org.netbeans.modules.db.metadata.model.api.MetadataElementHandleTest.demoProcedure'");
        stmt.close();

        metadata.refresh();

        schema = metadata.getDefaultSchema();

        assertNotNull(schema.getFunction("XY"));

        assertNull(schema.getProcedure("XY"));

        assertNull(paramHandle.resolve(metadata));


        // Negative test - what happens if you create a handle for null
        try {
            MetadataElementHandle<Catalog> bogusHandle = MetadataElementHandle.create((Catalog)null);

Return to bug 156304

Lines 188-191 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/MetadataUtilities.java (+17 lines)
188	throw new SQLException(t);	188	throw new SQLException(t);
189	}	189	}
190	}	190	}
		191
		192	/**
		193	* Call {@link DatabaseMetaData#geFunctions(String, String, String)},
		194	* wrapping any internal runtime exception into an {@link SQLException}.
		195	*/
		196	public static ResultSet getFunctions(DatabaseMetaData dmd,
		197	String catalog, String schemaPattern, String functionNamePattern)
		198	throws SQLException {
		199	try {
		200	return dmd.getFunctions(catalog, schemaPattern,
		201	functionNamePattern);
		202	} catch (SQLException e) {
		203	throw e;
		204	} catch (Throwable t) {
		205	throw new SQLException(t);
		206	}
		207	}
191	}	208	}

Lines 39-64 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/Procedure.java (-19 / +26 lines)
39	*	39	*
40	* Portions Copyrighted 2008 Sun Microsystems, Inc.	40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
41	*/	41	*/
42
43	package org.netbeans.modules.db.metadata.model.api;	42	package org.netbeans.modules.db.metadata.model.api;
44		43
45	import java.util.Collection;	44	import java.util.Collection;
46	import org.netbeans.modules.db.metadata.model.spi.ProcedureImplementation;	45	import org.netbeans.modules.db.metadata.model.spi.FunctionImplementation;
47		46
48	/**	47	/**
49	*	48	*
50	* @author Andrei Badea	49	* @author Andrei Badea, Matthias42
		50	*
		51	* @since db.metadata.model/1.0
51	*/	52	*/
52	public class Procedure extends Tuple {	53	public class Function extends Tuple {
53		54
54	final ProcedureImplementation impl;	55	final FunctionImplementation impl;
55		56
56	Procedure(ProcedureImplementation impl) {	57	Function(FunctionImplementation impl) {
57	this.impl = impl;	58	this.impl = impl;
58	}	59	}
59		60
60	/**	61	/**
61	* Returns the schema containing this table.	62	* Returns the schema containing this function.
62	*	63	*
63	* @return the parent schema.	64	* @return the parent schema.
64	*/	65	*/
Lines 76-94 Link Here
76	}	77	}
77		78
78	/**	79	/**
79	* Returns the return value of this procedure	80	* Returns the return value of this function
80	*	81	*
81	* @return the return value for this procedure	82	* @return the return value for this function
82	*/	83	*/
83	public Value getReturnValue() {	84	public Value getReturnValue() {
84	return impl.getReturnValue();	85	return impl.getReturnValue();
85	}	86	}
86		87
87	/**	88	/**
88	* Returns the columns in the result set for this procedure.	89	* Returns the columns in the result set for this function.
89	*	90	*
90	* @return the columns.	91	* @return the columns.
91	* @throws MetadataException if an error occurs while retrieving the metadata.	92	* @throws MetadataException if an error occurs while retrieving the
		93	* metadata.
92	*/	94	*/
93	public Collection<Column> getColumns() {	95	public Collection<Column> getColumns() {
94	return impl.getColumns();	96	return impl.getColumns();
Lines 98-115 Link Here
98	* Returns the column with the given name.	100	* Returns the column with the given name.
99	*	101	*
100	* @param name a column name.	102	* @param name a column name.
101	* @return a column named {@code name} or {@code null} if there is no such column.	103	* @return a column named {@code name} or {@code null} if there is no such
102	* @throws MetadataException if an error occurs while retrieving the metadata.	104	* column.
		105	* @throws MetadataException if an error occurs while retrieving the
		106	* metadata.
103	*/	107	*/
104	public Column getColumn(String name) {	108	public Column getColumn(String name) {
105	return impl.getColumn(name);	109	return impl.getColumn(name);
106	}	110	}
107		111
108	/**	112	/**
109	* Returns the list of parameters for this procedure	113	* Returns the list of parameters for this function
110	*	114	*
111	* @return the list of parameters for this procedure	115	* @return the list of parameters for this function
112	* @throws MetadataException if an error occurs while retrieving the metadata	116	* @throws MetadataException if an error occurs while retrieving the
		117	* metadata
113	*/	118	*/
114	public Collection<Parameter> getParameters() {	119	public Collection<Parameter> getParameters() {
115	return impl.getParameters();	120	return impl.getParameters();
Lines 117-123 Link Here
117		122
118	/**	123	/**
119	* Returns the parameter with the given name	124	* Returns the parameter with the given name
120	* @throws MetadataException if an error occurs while retrieving the metadata	125	*
		126	* @throws MetadataException if an error occurs while retrieving the
		127	* metadata
121	*/	128	*/
122	public Parameter getParameter(String name) {	129	public Parameter getParameter(String name) {
123	return impl.getParameter(name);	130	return impl.getParameter(name);
Lines 132-137 Link Here
132		139
133	@Override	140	@Override
134	public String toString() {	141	public String toString() {
135	return "View[name='" + getName() + "']"; // NOI18N	142	return "Function[name='" + getName() + "']"; // NOI18N
136	}	143	}
137	}	144	}

Lines 137-143 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/api/Schema.java (-1 / +27 lines)
137	}	137	}
138		138
139	/**	139	/**
140	* Get the list of procedures for thi shema	140	* Get the list of procedures for this schema
141	*	141	*
142	* @return the procedures	142	* @return the procedures
143	* @throws MetadataException if an error occurs while retrieving the metadata	143	* @throws MetadataException if an error occurs while retrieving the metadata
Lines 158-163 Link Here
158	}	158	}
159		159
160	/**	160	/**
		161	* Get the list of functions for this schema
		162	*
		163	* @return the functions
		164	* @throws MetadataException if an error occurs while retrieving the
		165	* metadata
		166	* @since db.metadata.model/1.0
		167	*/
		168	public Collection<Function> getFunctions() {
		169	return impl.getFunctions();
		170	}
		171
		172	/**
		173	* Return a function with the given name
		174	*
		175	* @param name a function name
		176	* @return a function named {@code name} or {@code null} if there is no such
		177	* function.
		178	* @throws MetadataException if an error occurs while retrieving the
		179	* metadata
		180	* @since db.metadata.model/1.0
		181	*/
		182	public Function getFunction(String name) {
		183	return impl.getFunction(name);
		184	}
		185
		186	/**
161	* Refresh the metadata for this schema	187	* Refresh the metadata for this schema
162	*/	188	*/
163	public void refresh() {	189	public void refresh() {

Lines 45-51 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCParameter.java (-6 / +6 lines)
45	import java.util.logging.Logger;	45	import java.util.logging.Logger;
46	import org.netbeans.modules.db.metadata.model.api.Nullable;	46	import org.netbeans.modules.db.metadata.model.api.Nullable;
47	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;	47	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
48	import org.netbeans.modules.db.metadata.model.api.Procedure;	48	import org.netbeans.modules.db.metadata.model.api.MetadataElement;
49	import org.netbeans.modules.db.metadata.model.api.SQLType;	49	import org.netbeans.modules.db.metadata.model.api.SQLType;
50	import org.netbeans.modules.db.metadata.model.spi.ParameterImplementation;	50	import org.netbeans.modules.db.metadata.model.spi.ParameterImplementation;
51		51
Lines 56-68 Link Here
56	public class JDBCParameter extends ParameterImplementation {	56	public class JDBCParameter extends ParameterImplementation {
57		57
58	private static final Logger LOGGER = Logger.getLogger(JDBCParameter.class.getName());	58	private static final Logger LOGGER = Logger.getLogger(JDBCParameter.class.getName());
59	private final JDBCProcedure jdbcProcedure;	59	private final MetadataElement parent;
60	private final Direction direction;	60	private final Direction direction;
61	private final int ordinalPosition;	61	private final int ordinalPosition;
62	private final JDBCValue value;	62	private final JDBCValue value;
63		63
64	public JDBCParameter(JDBCProcedure jdbcProcedure, JDBCValue value, Direction direction, int ordinalPosition) {	64	public JDBCParameter(MetadataElement parent, JDBCValue value, Direction direction, int ordinalPosition) {
65	this.jdbcProcedure = jdbcProcedure;	65	this.parent = parent;
66	this.direction = direction;	66	this.direction = direction;
67	this.value = value;	67	this.value = value;
68	this.ordinalPosition = ordinalPosition;	68	this.ordinalPosition = ordinalPosition;
Lines 74-81 Link Here
74	}	74	}
75		75
76	@Override	76	@Override
77	public Procedure getParent() {	77	public MetadataElement getParent() {
78	return jdbcProcedure.getProcedure();	78	return parent;
79	}	79	}
80		80
81	@Override	81	@Override

Lines 127-142 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCProcedure.java (-4 / +4 lines)
127	}	127	}
128		128
129	protected JDBCColumn createJDBCColumn(int position, ResultSet rs) throws SQLException {	129	protected JDBCColumn createJDBCColumn(int position, ResultSet rs) throws SQLException {
130	return new JDBCColumn(this.getProcedure(), position, JDBCValue.createProcedureValue(rs));	130	return new JDBCColumn(this.getProcedure(), position, JDBCValue.createProcedureValue(rs, this.getProcedure()));
131	}	131	}
132		132
133	protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {	133	protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {
134	Direction direction = JDBCUtils.getDirection(rs.getShort("COLUMN_TYPE"));	134	Direction direction = JDBCUtils.getProcedureDirection(rs.getShort("COLUMN_TYPE")); //NOI18N
135	return new JDBCParameter(this, JDBCValue.createProcedureValue(rs), direction, position);	135	return new JDBCParameter(this.getProcedure(), JDBCValue.createProcedureValue(rs, this.getProcedure()), direction, position);
136	}	136	}
137		137
138	protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {	138	protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {
139	return JDBCValue.createProcedureValue(rs);	139	return JDBCValue.createProcedureValue(rs, this.getProcedure());
140	}	140	}
141		141
142	protected void createProcedureInfo() {	142	protected void createProcedureInfo() {

Lines 152-158 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/JDBCUtils.java (-2 / +16 lines)
152	}	152	}
153	}	153	}
154		154
155	public static Direction getDirection(short sqlDirection) {	155	public static Direction getProcedureDirection(short sqlDirection) {
156	switch (sqlDirection) {	156	switch (sqlDirection) {
157	case DatabaseMetaData.procedureColumnOut:	157	case DatabaseMetaData.procedureColumnOut:
158	return Direction.OUT;	158	return Direction.OUT;
Lines 161-167 Link Here
161	case DatabaseMetaData.procedureColumnIn:	161	case DatabaseMetaData.procedureColumnIn:
162	return Direction.IN;	162	return Direction.IN;
163	default:	163	default:
164	LOGGER.log(Level.INFO, "Unknown direction value from DatabaseMetadat.getProcedureColumns(): " + sqlDirection);	164	LOGGER.log(Level.INFO, "Unknown direction value from DatabaseMetadata.getProcedureColumns(): " + sqlDirection);
		165	return Direction.IN;
		166	}
		167	}
		168
		169	public static Direction getFunctionDirection(short sqlDirection) {
		170	switch (sqlDirection) {
		171	case DatabaseMetaData.functionColumnOut:
		172	return Direction.OUT;
		173	case DatabaseMetaData.functionColumnInOut:
		174	return Direction.INOUT;
		175	case DatabaseMetaData.functionColumnIn:
		176	return Direction.IN;
		177	default:
		178	LOGGER.log(Level.INFO, "Unknown direction value from DatabaseMetadata.getFunctionColumns(): " + sqlDirection);
165	return Direction.IN;	179	return Direction.IN;
166	}	180	}
167	}	181	}

Lines 44-49 Link Here

(-)a/db.metadata.model/src/org/netbeans/modules/db/metadata/model/jdbc/mysql/MySQLProcedure.java (-5 / +6 lines)
44		44
45	import java.sql.ResultSet;	45	import java.sql.ResultSet;
46	import java.sql.SQLException;	46	import java.sql.SQLException;
		47	import org.netbeans.modules.db.metadata.model.api.MetadataElement;
47	import org.netbeans.modules.db.metadata.model.api.Nullable;	48	import org.netbeans.modules.db.metadata.model.api.Nullable;
48	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;	49	import org.netbeans.modules.db.metadata.model.api.Parameter.Direction;
49	import org.netbeans.modules.db.metadata.model.api.SQLType;	50	import org.netbeans.modules.db.metadata.model.api.SQLType;
Lines 64-76 Link Here
64		65
65	@Override	66	@Override
66	protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {	67	protected JDBCParameter createJDBCParameter(int position, ResultSet rs) throws SQLException {
67	Direction direction = JDBCUtils.getDirection(rs.getShort("COLUMN_TYPE"));	68	Direction direction = JDBCUtils.getProcedureDirection(rs.getShort("COLUMN_TYPE"));
68	return new JDBCParameter(this, createValue(rs), direction, position);	69	return new JDBCParameter(this.getProcedure(), createValue(rs, this.getProcedure()), direction, position);
69	}	70	}
70		71
71	@Override	72	@Override
72	protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {	73	protected JDBCValue createJDBCValue(ResultSet rs) throws SQLException {
73	return createValue(rs);	74	return createValue(rs, this.getProcedure());
74	}	75	}
75		76
76	@Override	77	@Override
Lines 85-91 Link Here
85	* Logged as a MySQL bug - http://bugs.mysql.com/bug.php?id=41269	86	* Logged as a MySQL bug - http://bugs.mysql.com/bug.php?id=41269
86	* When this is fixed this workaround will need to be backed out.	87	* When this is fixed this workaround will need to be backed out.
87	*/	88	*/
88	private static JDBCValue createValue(ResultSet rs) throws SQLException {	89	private static JDBCValue createValue(ResultSet rs, MetadataElement parent) throws SQLException {
89	String name = rs.getString("COLUMN_NAME");	90	String name = rs.getString("COLUMN_NAME");
90		91
91	int length = 0;	92	int length = 0;
Lines 101-107 Link Here
101	short radix = rs.getShort("RADIX");	102	short radix = rs.getShort("RADIX");
102	Nullable nullable = JDBCUtils.getProcedureNullable(rs.getShort("NULLABLE"));	103	Nullable nullable = JDBCUtils.getProcedureNullable(rs.getShort("NULLABLE"));
103		104
104	return new JDBCValue(name, type, length, precision, radix, scale, nullable);	105	return new JDBCValue(parent, name, type, length, precision, radix, scale, nullable);
105	}	106	}
106		107
107		108

Lines 44-49 Link Here

(-)a/db.metadata.model/test/unit/src/org/netbeans/modules/db/metadata/model/api/MetadataElementHandleTest.java (-1 / +70 lines)
44		44
45	import java.sql.Connection;	45	import java.sql.Connection;
46	import java.sql.DriverManager;	46	import java.sql.DriverManager;
		47	import java.sql.SQLException;
47	import java.sql.Statement;	48	import java.sql.Statement;
48	import org.netbeans.modules.db.metadata.model.api.MetadataElementHandle.Kind;	49	import org.netbeans.modules.db.metadata.model.api.MetadataElementHandle.Kind;
49	import org.netbeans.modules.db.metadata.model.jdbc.JDBCMetadata;	50	import org.netbeans.modules.db.metadata.model.jdbc.JDBCMetadata;
Lines 74-84 Link Here
74	stmt.executeUpdate("CREATE TABLE BAR (ID INT NOT NULL PRIMARY KEY, FOO_ID INT NOT NULL, FOREIGN KEY (FOO_ID) REFERENCES FOO)");	75	stmt.executeUpdate("CREATE TABLE BAR (ID INT NOT NULL PRIMARY KEY, FOO_ID INT NOT NULL, FOREIGN KEY (FOO_ID) REFERENCES FOO)");
75	stmt.executeUpdate("CREATE INDEX FOO_INDEX ON FOO(FOO)");	76	stmt.executeUpdate("CREATE INDEX FOO_INDEX ON FOO(FOO)");
76	stmt.executeUpdate("CREATE VIEW FOOVIEW AS SELECT * FROM FOO");	77	stmt.executeUpdate("CREATE VIEW FOOVIEW AS SELECT * FROM FOO");
		78	stmt.executeUpdate("CREATE PROCEDURE XY (IN S_MONTH INTEGER, IN S_DAYS VARCHAR(255)) "
		79	+ " DYNAMIC RESULT SETS 1 "
		80	+ " PARAMETER STYLE JAVA READS SQL DATA LANGUAGE JAVA "
		81	+ " EXTERNAL NAME 'org.netbeans.modules.db.metadata.model.api.MetadataElementHandleTest.demoProcedure'");
		82	stmt.executeUpdate("CREATE FUNCTION TO_DEGREES(RADIANS DOUBLE) RETURNS DOUBLE "
		83	+ "PARAMETER STYLE JAVA NO SQL LANGUAGE JAVA "
		84	+ "EXTERNAL NAME 'java.lang.Math.toDegrees'");
77	stmt.close();	85	stmt.close();
78	metadata = new JDBCMetadata(conn, "APP").getMetadata();	86	metadata = new JDBCMetadata(conn, "APP").getMetadata();
79	}	87	}
80		88
81	public void testResolve() {	89	public void testResolve() throws SQLException {
82	Catalog catalog = metadata.getDefaultCatalog();	90	Catalog catalog = metadata.getDefaultCatalog();
83	MetadataElementHandle<Catalog> catalogHandle = MetadataElementHandle.create(catalog);	91	MetadataElementHandle<Catalog> catalogHandle = MetadataElementHandle.create(catalog);
84	Catalog resolvedCatalog = catalogHandle.resolve(metadata);	92	Catalog resolvedCatalog = catalogHandle.resolve(metadata);
Lines 120-125 Link Here
120	View resolvedView = viewHandle.resolve(metadata);	128	View resolvedView = viewHandle.resolve(metadata);
121	assertSame(view, resolvedView);	129	assertSame(view, resolvedView);
122		130
		131	Function function = schema.getFunction("TO_DEGREES");
		132	MetadataElementHandle<Function> procedureHandle = MetadataElementHandle.create(function);
		133	Function resolvedFunction = procedureHandle.resolve(metadata);
		134	assertSame(function, resolvedFunction);
		135
		136	assertTrue(function.getParameters().size() > 0);
		137
		138	for (Parameter param : function.getParameters()) {
		139	MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(param);
		140	Parameter resolvedParam = paramHandle.resolve(metadata);
		141	assertSame(param, resolvedParam);
		142	}
		143
		144	Value value = function.getReturnValue();
		145	assertNotNull(value);
		146	MetadataElementHandle<Value> valueHandle = MetadataElementHandle.create(value);
		147	Value resolvedValue = valueHandle.resolve(metadata);
		148	assertSame(value, resolvedValue);
		149
		150	Procedure procedure = schema.getProcedure("XY");
		151	MetadataElementHandle<Procedure> functionHandle = MetadataElementHandle.create(procedure);
		152	Procedure resolvedProcedure = functionHandle.resolve(metadata);
		153	assertSame(procedure, resolvedProcedure);
		154
		155	assertTrue(procedure.getParameters().size() > 0);
		156
		157	for (Parameter param : procedure.getParameters()) {
		158	MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(param);
		159	Parameter resolvedParam = paramHandle.resolve(metadata);
		160	assertSame(param, resolvedParam);
		161	}
		162
		163	value = procedure.getReturnValue();
		164	assertNull(value);
		165
		166	// Ensure conflicting names of functions and procudures don't spill over
		167	// a MetadataElementHandle<Parameter> from a procedure must not be
		168	// resolvable against a function with the same "path" (Function name =
		169	// procedure name and same parameter name)
		170	procedure = schema.getProcedure("XY");
		171	MetadataElementHandle<Parameter> paramHandle = MetadataElementHandle.create(procedure.getParameters().iterator().next());
		172	assertNotNull(paramHandle.resolve(metadata));
		173
		174	Statement stmt = conn.createStatement();
		175	stmt.executeUpdate("DROP PROCEDURE XY");
		176	stmt.executeUpdate("CREATE FUNCTION XY (S_MONTH INTEGER, S_DAYS VARCHAR(255)) RETURNS DOUBLE "
		177	+ " PARAMETER STYLE JAVA READS SQL DATA LANGUAGE JAVA "
		178	+ " EXTERNAL NAME 'org.netbeans.modules.db.metadata.model.api.MetadataElementHandleTest.demoProcedure'");
		179	stmt.close();
		180
		181	metadata.refresh();
		182
		183	schema = metadata.getDefaultSchema();
		184
		185	assertNotNull(schema.getFunction("XY"));
		186
		187	assertNull(schema.getProcedure("XY"));
		188
		189	assertNull(paramHandle.resolve(metadata));
		190
		191
123	// Negative test - what happens if you create a handle for null	192	// Negative test - what happens if you create a handle for null
124	try {	193	try {
125	MetadataElementHandle<Catalog> bogusHandle = MetadataElementHandle.create((Catalog)null);	194	MetadataElementHandle<Catalog> bogusHandle = MetadataElementHandle.create((Catalog)null);