org.postgresql.util.PGobject Java Examples

protected static PGobject featureToPGobject(final Feature feature) throws SQLException {
    final Geometry geometry = feature.getGeometry();
    feature.setGeometry(null); // Do not serialize the geometry in the JSON object

    final String json;

    try {
        json = feature.serialize();
    } finally {
        feature.setGeometry(geometry);
    }

    final PGobject jsonbObject = new PGobject();
    jsonbObject.setType("jsonb");
    jsonbObject.setValue(json);
    return jsonbObject;
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return Range.integerRange(value);
    } else if("int8range".equals(type)) {
        return Range.longRange(value);
    } else if("numrange".equals(type)) {
        return Range.bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

@Override
public Object doNullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner) throws HibernateException, SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

	if (!HAS_POSTGRES_DRIVER) {
		return super.doNullSafeGet(rs, names, session, owner);
	}
	
    Object identifier = rs.getObject(names[0]);
    
    if (rs.wasNull()) {
        return null;
    }

    if (identifier instanceof PGobject) {
        PGobject pg = (PGobject) identifier;
        return getValueOfMethod().invoke(getMappedClass(), new Object[] { pg.getValue() });
    } else if (identifier instanceof String) { // some PostgreSQL Dialects / Versions return String not PGObject
        return getValueOfMethod().invoke(getMappedClass(), new Object[] { (String) identifier });
    } else {
        throw new IllegalArgumentException("PersistentEnum type expected PGobject, received " + identifier.getClass().getName() + " with value of '" + identifier + "'");
    }
}
 

@Override
public void doNullSafeSet(PreparedStatement preparedStatement, Map<String, String> value, int index,
		SharedSessionContractImplementor session) throws SQLException {

	if (value == null) {
		preparedStatement.setNull(index, Types.NULL);
	} else {

		String identifier = toString(value);
		;

		PGobject jsonObject = new PGobject();
		jsonObject.setType("json");
		jsonObject.setValue(identifier);

		preparedStatement.setObject(index, jsonObject);
	}
}
 

@Override
public Map<String, String> doNullSafeGet(ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner)
		throws HibernateException, SQLException {

	Object identifier = rs.getObject(names[0]);

	if (rs.wasNull()) {
		return null;
	}

	final String jsonText;
	if (identifier instanceof PGobject) {
		PGobject pg = (PGobject) identifier;
		jsonText = pg.getValue();
	} else if (identifier instanceof String) { // some PostgreSQL Dialects /
												// Versions return String
												// not PGObject
		jsonText = (String) identifier;
	} else {
		throw new IllegalArgumentException("PersistentJsonObjectAsPostgreSQLJson type expected PGobject, received "
				+ identifier.getClass().getName() + " with value of '" + identifier + "'");
	}

	return toMap(jsonText);
}
 

@Override
   public void nullSafeSet(PreparedStatement preparedStatement, Object value, int i, SharedSessionContractImplementor sessionImplementor) throws HibernateException, SQLException {
	String[] strings = (String[]) value;

	if (value == null) {
		preparedStatement.setNull(i, java.sql.Types.OTHER);
	} else {
		StringBuffer buffer = new StringBuffer();
		for (int j = 0; j < strings.length; j++) {
			buffer.append("\"" + strings[j] + "\"");
			if (j < strings.length - 1)
				buffer.append(",");
		}

		PGobject object = new PGobject();
		object.setValue("{" + buffer + "}");
		preparedStatement.setObject(i, object);
	}
}
 

@Override
protected boolean updateAuth(UUID uuid, String username, String accessToken) throws IOException {
    try (Connection c = postgreSQLHolder.getConnection();
         PreparedStatement s = c.prepareStatement(updateAuthSQL)) {
        s.setString(1, username); // Username case
        s.setString(2, accessToken);

        PGobject uuidObject = new PGobject();
        uuidObject.setType("uuid");
        uuidObject.setValue(uuid.toString());
        s.setObject(3, uuidObject);

        // Execute update
        s.setQueryTimeout(PostgreSQLSourceConfig.TIMEOUT);
        return s.executeUpdate() > 0;
    } catch (SQLException e) {
        throw new IOException(e);
    }
}
 

@Override
protected boolean updateServerID(UUID uuid, String serverID) throws IOException {
    try (Connection c = postgreSQLHolder.getConnection();
         PreparedStatement s = c.prepareStatement(updateServerIDSQL)) {
        s.setString(1, serverID);

        PGobject uuidObject = new PGobject();
        uuidObject.setType("uuid");
        uuidObject.setValue(uuid.toString());
        s.setObject(2, uuidObject);

        // Execute update
        s.setQueryTimeout(PostgreSQLSourceConfig.TIMEOUT);
        return s.executeUpdate() > 0;
    } catch (SQLException e) {
        throw new IOException(e);
    }
}
 

private Entry query(String sql, UUID value) throws IOException {
    try (Connection c = postgreSQLHolder.getConnection();
         PreparedStatement s = c.prepareStatement(sql)) {
        PGobject uuidObject = new PGobject();
        uuidObject.setType("uuid");
        uuidObject.setValue(value.toString());

        s.setObject(1, uuidObject);

        // Execute query
        s.setQueryTimeout(PostgreSQLSourceConfig.TIMEOUT);
        try (ResultSet set = s.executeQuery()) {
            return constructEntry(set);
        }
    } catch (SQLException e) {
        throw new IOException(e);
    }
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return integerRange(value);
    } else if("int8range".equals(type)) {
        return longRange(value);
    } else if("numrange".equals(type)) {
        return bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return integerRange(value);
    } else if("int8range".equals(type)) {
        return longRange(value);
    } else if("numrange".equals(type)) {
        return bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return Range.integerRange(value);
    } else if("int8range".equals(type)) {
        return Range.longRange(value);
    } else if("numrange".equals(type)) {
        return Range.bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return Range.integerRange(value);
    } else if("int8range".equals(type)) {
        return Range.longRange(value);
    } else if("numrange".equals(type)) {
        return Range.bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

@Override
protected Range get(ResultSet rs, String[] names, SessionImplementor session, Object owner) throws SQLException {
    PGobject pgObject = (PGobject) rs.getObject(names[0]);

    if (pgObject == null) {
        return null;
    }

    String type = pgObject.getType();
    String value = pgObject.getValue();

    if("int4range".equals(type)) {
        return integerRange(value);
    } else if("int8range".equals(type)) {
        return longRange(value);
    } else if("numrange".equals(type)) {
        return bigDecimalRange(value);
    } else {
        throw new IllegalStateException("The range type [" + type + "] is not supported!");
    }
}
 

protected final PGobject createJsonObject(String json) {
    try {
        PGobject jsonObject = new PGobject();
        jsonObject.setType("jsonb");
        jsonObject.setValue(json);
        return jsonObject;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@SuppressWarnings("unchecked")
@Override
public void initSpatialMetadata( String options ) throws Exception {
    if (!wasInitialized) {
        Connection jdbcConnection = getJdbcConnection();

        if (jdbcConnection instanceof PGConnection) {
            // FIXME how to enter in pooled mode
            PGConnection pgconn = (PGConnection) jdbcConnection;
            pgconn.addDataType("geometry", (Class< ? extends PGobject>) Class.forName("org.postgis.PGgeometry"));
            pgconn.addDataType("box3d", (Class< ? extends PGobject>) Class.forName("org.postgis.PGbox3d"));
            pgconn.addDataType("box2d", (Class< ? extends PGobject>) Class.forName("org.postgis.PGbox2d"));
        }
        wasInitialized = true;
    }
}
 

@Override
  public void doNullSafeSet(PreparedStatement preparedStatement, Object value, int index, SharedSessionContractImplementor session) throws SQLException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {

  	if (value == null) {
	preparedStatement.setNull(index, Types.NULL);
} else {				
	
	try {
		String identifier = getObjectWriter().writeValueAsString(value);
		
		Object jsonObject;
		if (HAS_POSTGRES_DRIVER) {
		
        	PGobject pgObject = new PGobject();
        	pgObject.setType("json");
        	pgObject.setValue(identifier);
        	jsonObject = pgObject;
		} else {
			jsonObject = identifier;
		}
		
           preparedStatement.setObject(index, jsonObject);
	} catch (JsonProcessingException e) {
		throw new HibernateException("Problem writing JSON String: " + e.getMessage(), e);
	}
}
  }
 

@Override
   public void nullSafeSet(PreparedStatement preparedStatement, Object value, int i, SharedSessionContractImplementor sessionImplementor) throws HibernateException, SQLException {
	if (value == null) {
		preparedStatement.setNull(i, java.sql.Types.OTHER);
	} else {
		PGobject object = new PGobject();
		object.setValue(((InetAddress) value).getHostAddress());
		object.setType("inet");
		preparedStatement.setObject(i, object);
	}
}
 

@Override
public void setNonNullParameter(PreparedStatement ps, int i,
        String parameter, JdbcType jdbcType) throws SQLException {
    PGobject jsonObject = new PGobject();
    jsonObject.setType("json");
    jsonObject.setValue(parameter);
    ps.setObject(i, jsonObject);
}
 

@Override
public void setJson(PreparedStatement preparedStatement, int parameterStartIndex, JsonNode json) {
    PGobject jsonObject = new PGobject();
    jsonObject.setType("jsonb");
    try {
        jsonObject.setValue(json.toString());
        preparedStatement.setObject(parameterStartIndex, jsonObject);
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
 

protected final Entity getEntity(ResultSet rs) throws SQLException {
    PGobject keyObject = (PGobject) rs.getObject("key");
    PGobject propertiesObject = (PGobject) rs.getObject("properties");

    Entity entity = new Entity(Key.deserialize(keyObject.getValue()));
    entity.deserializeProperties(propertiesObject.getValue());

    return entity;
}
 

@Override
public Object nullSafeGet( ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner ) throws HibernateException, SQLException
{
    final Object result = rs.getObject( names[0] );

    if ( !rs.wasNull() )
    {
        String content = null;

        if ( result instanceof String )
        {
            content = (String) result;
        }
        else if ( result instanceof PGobject )
        {
            content = ((PGobject) result).getValue();
        }

        // Other types currently ignored

        if ( content != null )
        {
            return content.toString();
        }
    }

    return null;
}
 

@Override
protected void storeGrade(PreparedStatement pst, int position, Grading grd) throws SQLException {
	PGobject jsonObject = new PGobject();
	jsonObject.setType("json");
	jsonObject.setValue(serialiser.toJsonElement(grd).toString());
	pst.setObject(position, jsonObject);
}
 

@Override
protected void storeCard(PreparedStatement pst, int position, MagicCard mc) throws SQLException {
	
	PGobject jsonObject = new PGobject();
	jsonObject.setType("json");
	jsonObject.setValue(serialiser.toJsonElement(mc).toString());
	pst.setObject(position, jsonObject);
}
 

private @NotNull Object createPgObject(@NotNull String value, @NotNull String typeName) {
    try {
        PGobject object = new PGobject();
        object.setType(typeName);
        object.setValue(value);
        return object;
    } catch (SQLException e) {
        throw convertException(e);
    }
}
 

private void updateJobParamaters( final Context context, int dataValuesPageSize )
    throws JsonProcessingException, SQLException
{
    if ( dataValuesPageSize > 0 )
    {
        Map<Integer, JobParameters> updatedJobParameters = new HashMap<>();

        String sql = "SELECT jobconfigurationid, jsonbjobparameters FROM jobconfiguration " +
            "WHERE jobtype = '" + JobType.DATA_SYNC.name() + "';";
        try ( Statement stmt = context.getConnection().createStatement();
              ResultSet rs = stmt.executeQuery( sql ); )
        {
            while ( rs.next())
            {
                DataSynchronizationJobParameters jobparams = reader
                    .readValue( rs.getString( "jsonbjobparameters" ) );
                jobparams.setPageSize( dataValuesPageSize );

                updatedJobParameters.put( rs.getInt( "jobconfigurationid" ), jobparams );
            }
        }

        for ( Map.Entry<Integer, JobParameters> jobParams : updatedJobParameters.entrySet() )
        {
            try ( PreparedStatement ps = context.getConnection()
                .prepareStatement( "UPDATE jobconfiguration SET jsonbjobparameters = ? where  jobconfigurationid = ?;" ) )
            {
                PGobject pg = new PGobject();
                pg.setType( "jsonb" );
                pg.setValue( writer.writeValueAsString( jobParams.getValue() ) );

                ps.setObject( 1, pg );
                ps.setInt( 2, jobParams.getKey() );

                ps.execute();
            }
        }
    }
}
 

@Override
public void nullSafeSet( PreparedStatement ps, Object value, int idx, SharedSessionContractImplementor session ) throws HibernateException, SQLException
{
    if ( value == null )
    {
        ps.setObject( idx, null );
        return;
    }

    PGobject pg = new PGobject();
    pg.setType( "jsonb" );
    pg.setValue( convertObjectToJson( value ) );

    ps.setObject( idx, pg );
}
 

@Override
public Object nullSafeGet( ResultSet rs, String[] names, SharedSessionContractImplementor session, Object owner ) throws HibernateException, SQLException
{
    final Object result = rs.getObject( names[0] );

    if ( !rs.wasNull() )
    {
        String content = null;

        if ( result instanceof String )
        {
            content = (String) result;
        }
        else if ( result instanceof PGobject )
        {
            content = ((PGobject) result).getValue();
        }

        // Other types currently ignored

        if ( content != null )
        {
            return convertJsonToObject( content );
        }
    }

    return null;
}
 

@Override
public void nullSafeSet( PreparedStatement ps, Object value, int idx, SharedSessionContractImplementor session ) throws HibernateException, SQLException
{
    if ( value == null )
    {
        ps.setObject( idx, null );
        return;
    }

    PGobject pg = new PGobject();
    pg.setType( "jsonb" );
    pg.setValue( value.toString() );

    ps.setObject( idx, pg );
}
 

private static SliceWriteFunction typedVarcharWriteFunction(String jdbcTypeName)
{
    return (statement, index, value) -> {
        PGobject pgObject = new PGobject();
        pgObject.setType(jdbcTypeName);
        pgObject.setValue(value.toStringUtf8());
        statement.setObject(index, pgObject);
    };
}