Ошибка добавления в postgresql

package app.servlets;
 
import app.dao.jdbcdao.PlanetJDBCDAO;
import app.entities.Planet;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.SQLException;
import java.util.UUID;
 
public class ControllerServlet extends HttpServlet {
 
    private static String ADD_OR_EDIT = "add_edit.jsp";
    private static String LIST_USER = "list.jsp";
 
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String forward = "";
        String action = req.getParameter("action");
 
        try (PlanetJDBCDAO dao = new PlanetJDBCDAO()) {
            if (action.equalsIgnoreCase("select")) {
                forward = LIST_USER;
                req.setAttribute("Title", "Планеты");
            } else if (action.equalsIgnoreCase("delete")) {
                UUID userId = UUID.fromString(req.getParameter("planetId"));
                dao.delete(userId);
                forward = LIST_USER;
            } else if (action.equalsIgnoreCase("update")) {
                forward = ADD_OR_EDIT;
                Planet planet = dao.getById(UUID.fromString(req.getParameter("planetId")));
                req.setAttribute("planet", planet);
                req.setAttribute("Title", "Изменить");
            } else if (action.equalsIgnoreCase("insert")) {
                forward = ADD_OR_EDIT;
                req.setAttribute("Title", "Добавить");
            }
 
            req.getRequestDispatcher(forward).forward(req, resp);
        } catch (SQLException e) {
            e.printStackTrace();
        }
 
    }
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Planet planet = (Planet) req.getAttribute("planet");
        String planetId = req.getParameter("planetId");
        try (PlanetJDBCDAO dao = new PlanetJDBCDAO()) {
            if (planetId == null || planetId.isEmpty()) {
                dao.create(planet);
            } else {
                dao.update(UUID.fromString(planetId), planet);
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
//        req.getRequestDispatcher("/ControllerServlet?action=select").forward(req, resp);
        resp.sendRedirect("/ControllerServlet?action=select");
 
    }
}

package app.entities;
 
 
import java.io.Serializable;
import java.util.UUID;
 
public class Planet implements Serializable {
    private UUID id;
 
    private String name;
    private int satellites;
    private double density;
    private boolean fromSolarSystem;
 
    public Planet(String Name, int Satellites, float Density, boolean FromSolarSystem) {
        id = UUID.randomUUID();
        name = Name;
        satellites = Satellites;
        density = Density;
        fromSolarSystem = FromSolarSystem;
    }
 
    public Planet() {
        id = UUID.randomUUID();
    }
 
    public UUID getId() { return id; }
 
    public void setId(UUID id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getSatellites() {
        return satellites;
    }
 
    public void setSatellites(int satellites) {
        this.satellites = satellites;
    }
 
    public double getDensity() {
        return density;
    }
 
    public void setDensity(double density) {
        this.density = density;
    }
 
    public boolean isFromSolarSystem() {
        return fromSolarSystem;
    }
 
    public void setFromSolarSystem(boolean fromSolarSystem) {
        this.fromSolarSystem = fromSolarSystem;
    }
 
    @Override
    public String toString() {
        return id + " | " + name + " | " + satellites + " | " + density + " | " + fromSolarSystem;
    }
}

package app.dao.jdbcdao;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
 
import app.dao.PlanetDAO;
import app.entities.Planet;
 
public class PlanetJDBCDAO implements PlanetDAO, AutoCloseable {
 
    private Connection conn;
 
    public PlanetJDBCDAO() {
        try {
            String url = "jdbc:postgresql://localhost:5432/lab";
            String user = "postgres";
            String password = "1234";
            conn = DriverManager.getConnection(url, user, password);
        }
        catch(SQLException ex) {
            throw new IllegalArgumentException(ex);
        }
    }
 
    private void setPlanetFields(Planet s, ResultSet rs) throws SQLException {
        s.setId((UUID) rs.getObject("id"));
        s.setName(rs.getString("name"));
        s.setDensity(rs.getFloat("density"));
        s.setSatellites(rs.getInt("satellites"));
        s.setFromSolarSystem(rs.getBoolean("fromSolarSystem"));
    }
 
    @Override
    public List<Planet> getPlanets() {
        String sql = "SELECT * FROM planets;";
        List<Planet> list = new ArrayList<>();
        try (PreparedStatement ps = conn.prepareStatement(sql)) {
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                Planet s = new Planet();
                setPlanetFields(s, rs);
                list.add(s);
            }
        } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
        return list;
    }
 
    @Override
    public Planet getById(UUID id) {
        String sql = "SELECT * FROM planets WHERE id = ?;";
        Planet s = new Planet();
        try (PreparedStatement ps = conn.prepareStatement(sql)) {
 
            ps.setObject(1, id);
 
            ResultSet rs = ps.executeQuery();
            if (rs.next()) {
                setPlanetFields(s, rs);
            } else {
                throw new IllegalArgumentException("There is no rows with this id " + id);
            }
        } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
        return s;
    }
 
    @Override
    public Planet getByName(String name) {
        String sql = "SELECT * FROM planets WHERE name = ?;";
        Planet s = new Planet();
        try (PreparedStatement ps = conn.prepareStatement(sql)) {
 
            ps.setString(1, name);
 
            ResultSet rs = ps.executeQuery();
            if (rs.next()) {
                setPlanetFields(s, rs);
            } else {
                throw new IllegalArgumentException("There is no rows with this name " + name);
            }
        } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
        return s;
    }
 
    @Override
    public void create(Planet planet) {
        String sql = "INSERT INTO planets (id, name, satellites, density, fromSolarSystem) VALUES(?, ?, ?, ?, ?);";
 
            try(PreparedStatement ps = conn.prepareStatement(sql)) {
                try {
                    ps.setObject(1, planet.getId());
                }
                catch (Exception e) {
                    System.out.println(e.getMessage());
                }
                ps.setString(2, planet.getName());
                ps.setInt(3, planet.getSatellites());
                ps.setDouble(4, planet.getDensity());
                ps.setBoolean(5, planet.isFromSolarSystem());
                    ps.executeUpdate();
 
            } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
                throw new IllegalArgumentException(ex);
            }
        }
 
 
 
 
 
    @Override
    public void update(UUID id, Planet newPlanet) {
        String sql = "UPDATE planets SET " +
                "name = ?, " +
                "satellites = ?, " +
                "density = ?, " +
                "fromSolarSystem = ? " +
                "WHERE id = ?;";
        try(PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setString(1, newPlanet.getName());
            ps.setInt(2, newPlanet.getSatellites());
            ps.setDouble(3, newPlanet.getDensity());
            ps.setBoolean(4, newPlanet.isFromSolarSystem());
            ps.setObject(5, id);
            ps.executeUpdate();
        } catch (SQLException ex) {
            throw  new IllegalArgumentException(ex);
        }
    }
 
    @Override
    public void delete(UUID id) {
        String sql = "DELETE FROM planets WHERE id=?;";
        try(PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setObject(1, id);
            ps.executeUpdate();
        } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
    }
 
    @Override
    public int count() {
        String sql = "SELECT COUNT(*) AS count FROM planets;";
        try(PreparedStatement ps = conn.prepareStatement(sql)) {
            ResultSet rs = ps.executeQuery();
            rs.next();
            return rs.getInt("count");
 
        } catch (SQLException ex) {
//            Logger.getLogger(PlanetJDBCDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new IllegalArgumentException(ex);
        }
    }
 
    @Override
    public void close() throws SQLException {
        if(conn!=null && !conn.isClosed())
            conn.close();
    }
}