All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • jakarta.faces.model.ResultSetDataModel Maven / Gradle / Ivy

    There is a newer version: 11.0.0-M4
    Show newest version
    /*
 * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0, which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * This Source Code may also be made available under the following Secondary
 * Licenses when the conditions for such availability set forth in the
 * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
 * version 2 with the GNU Classpath Exception, which is available at
 * https://www.gnu.org/software/classpath/license.html.
 *
 * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 */

package jakarta.faces.model;

import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import jakarta.faces.FacesException;

/**
 * 
    
 * ResultSetDataModel is a convenience implementation of {@link DataModel} that wraps a
 * ResultSet of Java objects. Note that the specified ResultSet MUST be
 * scrollable. In addition, if input components (that will be updating model values) reference this object in value
 * binding expressions, the specified ResultSet MUST be updatable.
 * 
    
 */

public class ResultSetDataModel extends DataModel> {

    // ------------------------------------------------------------ Constructors

    /**
     * 
    
     * Construct a new {@link ResultSetDataModel} with no specified wrapped data.
     * 
    
     */
    public ResultSetDataModel() {

        this(null);

    }

    /**
     * 
    
     * Construct a new {@link ResultSetDataModel} wrapping the specified ResultSet.
     * 
    
     *
     * @param resultSet ResultSet to be wrapped (if any)
     */
    public ResultSetDataModel(ResultSet resultSet) {

        super();
        setWrappedData(resultSet);

    }

    // ------------------------------------------------------ Instance Variables

    // The current row index (zero relative)
    private int index = -1;

    // The metadata for the ResultSet we are wrapping (lazily instantiated)
    private ResultSetMetaData metadata = null;

    // The ResultSet we are wrapping
    private ResultSet resultSet = null;

    // Has the row at the current index been updated?
    private boolean updated = false;

    // -------------------------------------------------------------- Properties

    /**
     * 
    
     * Return true if there is wrappedData available, and the result of calling
     * absolute() on the underlying ResultSet, passing the current value of rowIndex
     * plus one (to account for the fact that ResultSet uses one-relative indexing), returns true.
     * Otherwise, return false.
     * 
    
     *
     * @throws FacesException if an error occurs getting the row availability
     */
    @Override
    public boolean isRowAvailable() {

        if (resultSet == null) {
            return false;
        } else if (index < 0) {
            return false;
        }
        try {
            if (resultSet.absolute(index + 1)) {
                return true;
            } else {
                return false;
            }
        } catch (SQLException e) {
            throw new FacesException(e);
        }

    }

    /**
     * 
    
     * Return -1, since ResultSet does not provide a standard way to determine the number of available rows
     * without scrolling through the entire ResultSet, and this can be very expensive if the number of rows is
     * large.
     * 
    
     *
     * @throws FacesException if an error occurs getting the row count
     */
    @Override
    public int getRowCount() {

        return -1;

    }

    /**
     * 
    
     * If row data is available, return a Map representing the values of the columns for the row specified by
     * rowIndex, keyed by the corresponding column names. If no wrapped data is available, return
     * null.
     * 
    
     *
     * 
    
     * If a non-null Map is returned, its behavior must correspond to the contract for a mutable
     * Map as described in the JavaDocs for AbstractMap, with the following exceptions and
     * specialized behavior:
     * 
    
     * 
      
     *
     * 
    • The Map, and any supporting objects it returns, must perform all column name comparisons in a
     * case-insensitive manner. This case-insensitivity must be implemented using a case-insensitive
     * Comparator, such as String.CASE_INSENSITIVE_ORDER.
      • 
     *
     * 
    • The following methods must throw UnsupportedOperationException: clear(),
     * remove().
      • 
     * 
    • The entrySet() method must return a Set that has the following behavior:
     * 
        
     * 
      • Throw UnsupportedOperationException for any attempt to add or remove entries from the
     * Set, either directly or indirectly through an Iterator returned by the
     * Set.
        • 
     * 
      • Updates to the value of an entry in this set must write through to the corresponding
     * column value in the underlying ResultSet.
        • 
     * 
      
     * 
      • 
     * 
    • The keySet() method must return a Set that throws
     * UnsupportedOperationException on any attempt to add or remove keys, either directly or through an
     * Iterator returned by the Set.
      • 
     * 
    • The put() method must throw IllegalArgumentException if a key value for which
     * containsKey() returns false is specified. However, if a key already present in the
     * Map is specified, the specified value must write through to the corresponding column value in the
     * underlying ResultSet.
      • 
     * 
    • The values() method must return a Collection that throws
     * UnsupportedOperationException on any attempt to add or remove values, either directly or through an
     * Iterator returned by the Collection.
      • 
     * 
    
     *
     * @throws FacesException if an error occurs getting the row data
     * @throws IllegalArgumentException if now row data is available at the currently specified row index
     */
    @Override
    public Map getRowData() {

        if (resultSet == null) {
            return null;
        } else if (!isRowAvailable()) {
            throw new NoRowAvailableException();
        }
        try {
            getMetaData();
            return new ResultSetMap(this, String.CASE_INSENSITIVE_ORDER);
        } catch (SQLException e) {
            throw new FacesException(e);
        }

    }

    /**
     * @throws FacesException {@inheritDoc}
     */
    @Override
    public int getRowIndex() {

        return index;

    }

    /**
     * @throws FacesException {@inheritDoc}
     * @throws IllegalArgumentException {@inheritDoc}
     */
    @Override
    public void setRowIndex(int rowIndex) {

        if (rowIndex < -1) {
            throw new IllegalArgumentException();
        }

        // Tell the ResultSet that the previous row was updated if necessary
        if (updated && resultSet != null) {
            try {
                if (!resultSet.rowDeleted()) {
                    resultSet.updateRow();
                }
                updated = false;
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        int old = index;
        index = rowIndex;
        if (resultSet == null) {
            return;
        }
        DataModelListener[] listeners = getDataModelListeners();
        if (old != index && listeners != null) {
            Object rowData = null;
            if (isRowAvailable()) {
                rowData = getRowData();
            }
            DataModelEvent event = new DataModelEvent(this, index, rowData);
            int n = listeners.length;
            for (int i = 0; i < n; i++) {
                if (null != listeners[i]) {
                    listeners[i].rowSelected(event);
                }
            }
        }

    }

    @Override
    public Object getWrappedData() {

        return resultSet;

    }

    /**
     * @throws ClassCastException {@inheritDoc}
     */
    @Override
    public void setWrappedData(Object data) {

        if (data == null) {
            metadata = null;
            resultSet = null;
            setRowIndex(-1);
        } else {
            metadata = null;
            resultSet = (ResultSet) data;
            index = -1;
            setRowIndex(0);
        }
    }

    // --------------------------------------------------------- Private Methods

    /**
     * 
    
     * Return the ResultSetMetaData for the ResultSet we are wrapping, caching it the first time
     * it is returned.
     * 
    
     *
     * @throws FacesException if the ResultSetMetaData cannot be acquired
     */
    private ResultSetMetaData getMetaData() {

        if (metadata == null) {
            try {
                metadata = resultSet.getMetaData();
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }
        return metadata;

    }

    /**
     * 
    
     * Mark the current row as having been updated, so that we will call updateRow() before moving elsewhere.
     * 
    
     */
    private void updated() {

        updated = true;

    }

    // --------------------------------------------------------- Private Classes

    // Private implementation of Map that delegates column get and put
    // operations to the underlying ResultSet, after setting the required
    // row index
    // NOT SERIALIZABLE
    @SuppressWarnings({ "serial" })
    private static class ResultSetMap extends TreeMap {

        private ResultSetDataModel model;

        public ResultSetMap(ResultSetDataModel model, Comparator comparator) throws SQLException {

            super(comparator);
            this.model = model;
            index = model.index;
            model.resultSet.absolute(index + 1);
            int n = model.metadata.getColumnCount();
            for (int i = 1; i <= n; i++) {
                super.put(model.metadata.getColumnName(i), model.metadata.getColumnName(i));
            }
        }

        // The zero-relative row index of our row
        private int index;

        // Removing entries is not allowed
        @Override
        public void clear() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean containsValue(Object value) {
            for (Iterator i = entrySet().iterator(); i.hasNext();) {
                Map.Entry entry = (Map.Entry) i.next();
                Object contained = entry.getValue();
                if (value == null) {
                    if (contained == null) {
                        return true;
                    }
                } else {
                    if (value.equals(contained)) {
                        return true;
                    }
                }
            }
            return false;
        }

        @Override
        public Set> entrySet() {
            return new ResultSetEntries(this);
        }

        @Override
        public Object get(Object key) {
            if (!containsKey(key)) {
                return null;
            }
            try {
                model.resultSet.absolute(index + 1);
                return model.resultSet.getObject((String) realKey(key));
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        @Override
        public Set keySet() {
            return new ResultSetKeys(this);
        }

        @Override
        public Object put(String key, Object value) {
            if (!containsKey(key)) {
                throw new IllegalArgumentException();
            }

            try {
                model.resultSet.absolute(index + 1);
                Object previous = model.resultSet.getObject((String) realKey(key));
                if (previous == null && value == null) {
                    return previous;
                } else if (previous != null && value != null && previous.equals(value)) {
                    return previous;
                }
                model.resultSet.updateObject((String) realKey(key), value);
                model.updated();
                return previous;
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        @Override
        public void putAll(Map map) {
            for (Map.Entry entry : map.entrySet()) {
                put(entry.getKey(), entry.getValue());
            }
        }

        // Removing entries is not allowed
        @Override
        public Object remove(Object key) {
            throw new UnsupportedOperationException();
        }

        @Override
        public Collection values() {
            return new ResultSetValues(this);
        }

        Object realKey(Object key) {
            return super.get(key);
        }

        Iterator realKeys() {
            return super.keySet().iterator();
        }

        private void writeObject(ObjectOutputStream out) throws IOException {
            throw new NotSerializableException();
        }

        private void readObject(ObjectInputStream in) throws IOException {
            throw new NotSerializableException();
        }

    }

    // Private implementation of Set that implements the entrySet() behavior
    // for ResultSetMap
    private static class ResultSetEntries extends AbstractSet> {

        public ResultSetEntries(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        // Adding entries is not allowed
        @Override
        public boolean add(Map.Entry o) {
            throw new UnsupportedOperationException();
        }

        // Adding entries is not allowed
        @Override
        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        @Override
        public void clear() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean contains(Object o) {
            if (o == null) {
                throw new NullPointerException();
            }
            if (!(o instanceof Map.Entry)) {
                return false;
            }
            Map.Entry e = (Map.Entry) o;
            Object k = e.getKey();
            Object v = e.getValue();
            if (!map.containsKey(k)) {
                return false;
            }
            if (v == null) {
                return map.get(k) == null;
            } else {
                return v.equals(map.get(k));
            }
        }

        @Override
        public boolean isEmpty() {
            return map.isEmpty();
        }

        @Override
        public Iterator> iterator() {
            return new ResultSetEntriesIterator(map);
        }

        // Removing entries is not allowed
        @Override
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        @Override
        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        @Override
        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public int size() {
            return map.size();
        }

    }

    // Private implementation of Iterator that implements the iterator()
    // behavior for the Set returned by entrySet() from ResultSetMap
    private static class ResultSetEntriesIterator implements Iterator> {

        public ResultSetEntriesIterator(ResultSetMap map) {
            this.map = map;
            keys = map.keySet().iterator();
        }

        private ResultSetMap map;
        private Iterator keys;

        @Override
        public boolean hasNext() {
            return keys.hasNext();
        }

        @Override
        public Map.Entry next() {
            String key = keys.next();
            return new ResultSetEntry(map, key);
        }

        // Removing entries is not allowed
        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    // Private implementation of Map.Entry that implements the behavior for
    // a single entry from the Set returned by entrySet() from ResultSetMap
    private static class ResultSetEntry implements Map.Entry {

        public ResultSetEntry(ResultSetMap map, String key) {
            this.map = map;
            this.key = key;
        }

        private ResultSetMap map;
        private String key;

        @Override
        public boolean equals(Object o) {
            if (o == null) {
                return false;
            }
            if (!(o instanceof Map.Entry)) {
                return false;
            }
            Map.Entry e = (Map.Entry) o;
            if (key == null) {
                if (e.getKey() != null) {
                    return false;
                }
            } else {
                if (!key.equals(e.getKey())) {
                    return false;
                }
            }
            Object v = map.get(key);
            if (v == null) {
                if (e.getValue() != null) {
                    return false;
                }
            } else {
                if (!v.equals(e.getValue())) {
                    return false;
                }
            }
            return true;
        }

        @Override
        public String getKey() {
            return key;
        }

        @Override
        public Object getValue() {
            return map.get(key);
        }

        @Override
        public int hashCode() {
            Object value = map.get(key);
            return (key == null ? 0 : key.hashCode()) ^ (value == null ? 0 : value.hashCode());
        }

        @Override
        public Object setValue(Object value) {
            Object previous = map.get(key);
            map.put(key, value);
            return previous;
        }

    }

    // Private implementation of Set that implements the keySet() behavior
    // for ResultSetMap
    private static class ResultSetKeys extends AbstractSet {

        public ResultSetKeys(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        // Adding keys is not allowed
        @Override
        public boolean add(String o) {
            throw new UnsupportedOperationException();
        }

        // Adding keys is not allowed
        @Override
        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        @Override
        public void clear() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean contains(Object o) {
            return map.containsKey(o);
        }

        @Override
        public boolean isEmpty() {
            return map.isEmpty();
        }

        @Override
        public Iterator iterator() {
            return new ResultSetKeysIterator(map);
        }

        // Removing keys is not allowed
        @Override
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        @Override
        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        @Override
        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public int size() {
            return map.size();
        }

    }

    // Private implementation of Iterator that implements the iterator()
    // behavior for the Set returned by keySet() from ResultSetMap
    private static class ResultSetKeysIterator implements Iterator {

        public ResultSetKeysIterator(ResultSetMap map) {
            keys = map.realKeys();
        }

        private Iterator keys;

        @Override
        public boolean hasNext() {
            return keys.hasNext();
        }

        @Override
        public String next() {
            return keys.next();
        }

        // Removing keys is not allowed
        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

    // Private implementation of Collection that implements the behavior
    // for the Collection returned by values() from ResultSetMap
    private static class ResultSetValues extends AbstractCollection {

        public ResultSetValues(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        @Override
        public boolean add(Object o) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void clear() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean contains(Object value) {
            return map.containsValue(value);
        }

        @Override
        public Iterator iterator() {
            return new ResultSetValuesIterator(map);
        }

        @Override
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        @Override
        public int size() {
            return map.size();
        }

    }

    // Private implementation of Iterator that implements the behavior
    // for the Iterator returned by values().iterator() from ResultSetMap
    private static class ResultSetValuesIterator implements Iterator {

        public ResultSetValuesIterator(ResultSetMap map) {
            this.map = map;
            keys = map.keySet().iterator();
        }

        private ResultSetMap map;
        private Iterator keys;

        @Override
        public boolean hasNext() {
            return keys.hasNext();
        }

        @Override
        public Object next() {
            return map.get(keys.next());
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }

}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy