Java PGConnection类代码示例

import org.postgresql.PGConnection; //导入依赖的package包/类
public void saveAll(PGConnection connection, Stream<TEntity> entities) throws SQLException {

        CopyManager cpManager = connection.getCopyAPI();
        CopyIn copyIn = cpManager.copyIn(getCopyCommand());

        try (PgBinaryWriter bw = new PgBinaryWriter()) {

            // Wrap the CopyOutputStream in our own Writer:
            bw.open(new PGCopyOutputStream(copyIn));

            // Insert Each Column:
            entities.forEach(entity -> this.saveEntity(bw, entity));
        }
    }
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public void run()
{
    trysleep(2000);
    while (!done) {
        try {
            PGConnection pg = (PGConnection)getConnection();
            if (pg == null) {
                log.info("watcher: connection was null");
                trysleep(5000);
                continue;
            }
            PGNotification notifications[] = pg.getNotifications();
            if (notifications != null) {
                Set<String> changes = new HashSet<String>();
                for (PGNotification n : notifications) {
                    changes.add(n.getParameter());
                }
                Messenger.sendEvent(MT.DATABASE_NOTIFICATION, changes);
            }
        } catch (Throwable e) {
            log.log(Level.WARNING, "ConnectionWatcher exception: " + e, e);
        }

        trysleep(500);
    }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
@Override
public void createFile(JDBCSequentialFile file) throws SQLException {
   synchronized (connection) {
      try {
         connection.setAutoCommit(false);

         LargeObjectManager lobjManager = ((PGConnection) connection).getLargeObjectAPI();
         long oid = lobjManager.createLO();

         createFile.setString(1, file.getFileName());
         createFile.setString(2, file.getExtension());
         createFile.setLong(3, oid);
         createFile.executeUpdate();

         try (ResultSet keys = createFile.getGeneratedKeys()) {
            keys.next();
            file.setId(keys.getLong(1));
         }
         connection.commit();
      } catch (SQLException e) {
         connection.rollback();
         throw e;
      }
   }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
@Override
public int writeToFile(JDBCSequentialFile file, byte[] data) throws SQLException {
   synchronized (connection) {
      LargeObjectManager lobjManager = ((PGConnection) connection).getLargeObjectAPI();
      LargeObject largeObject = null;

      Long oid = getOID(file);
      try {
         connection.setAutoCommit(false);
         largeObject = lobjManager.open(oid, LargeObjectManager.WRITE);
         largeObject.seek(largeObject.size());
         largeObject.write(data);
         largeObject.close();
         connection.commit();
      } catch (Exception e) {
         connection.rollback();
         throw e;
      }
      return data.length;
   }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
private int getPostGresLargeObjectSize(JDBCSequentialFile file) throws SQLException {
   LargeObjectManager lobjManager = ((PGConnection) connection).getLargeObjectAPI();

   int size = 0;
   Long oid = getOID(file);
   if (oid != null) {
      synchronized (connection) {
         try {
            connection.setAutoCommit(false);
            LargeObject largeObject = lobjManager.open(oid, LargeObjectManager.READ);
            size = largeObject.size();
            largeObject.close();
            connection.commit();
         } catch (SQLException e) {
            connection.rollback();
            throw e;
         }
      }
   }
   return size;
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
@Override
public void execute(Connection connection,
                    TypeConverterStore converterStore,
                    SqlCache sqlCache,
                    DataSourceAdapter dataSourceAdapter) throws Exception {
    String theSql = sql == null ? sqlCache.get(filename) : sql;
    PGConnection pgConn = dataSourceAdapter.unwrapPgConnection(connection);
    CopyManager copyManager = (pgConn).getCopyAPI();
    fileReader = new FileReader(copyFile);
    copyManager.copyIn(theSql, fileReader);
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public static PGConnection mapColumnTypes(PGConnection pgConn)
{
  try
  {
    pgConn.addDataType("geometry", org.postgis.jts.JtsGeometry.class);
    pgConn.addDataType("box3d", org.postgis.PGbox3d.class);
    pgConn.addDataType("box2d", org.postgis.PGbox2d.class);
  }
  catch (SQLException e)
  {
    String errMsg = e.getMessage();
    throw new ProgrammingErrorException(errMsg, e);
  }

  return pgConn;
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
/**
 *
 * @param con open postgres! connection
 * @param folder the classpath folder to scan for table data files
 * @param truncate if true first truncates the tables
 * @throws Exception
 */
public static void load(Connection con, String folder, boolean truncate) throws Exception {
    con.setAutoCommit(false);
    LOG.info("Load data from " + folder);
    CopyManager copy = ((PGConnection)con).getCopyAPI();
    List<String> tables = listTables(folder);
    if (truncate) {
        truncate(con, tables);
    }
    con.commit();

    for (String table : tables) {
        LOG.debug("Load table " + table);
        InputStreamWithoutHeader in = new InputStreamWithoutHeader(FileUtils.classpathStream(folder + "/" + table + FILE_SUFFIX), '\t', '\n');
        String header = HEADER_JOINER.join(in.header);
        copy.copyIn("COPY " + table + "(" + header + ") FROM STDOUT WITH NULL '\\N'", in);
    }
    con.commit();
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
private void do_copy( PGBulkLoaderMeta meta, boolean wait ) throws KettleException {
  Runtime rt = Runtime.getRuntime();

  data.db = new Database( this, meta.getDatabaseMeta() );
  String copyCmd = getCopyCommand( );
  try {
    connect();

    processTruncate();

    logBasic( "Launching command: " + copyCmd );
    pgCopyOut = new PGCopyOutputStream( (PGConnection) data.db.getConnection(), copyCmd );

  } catch ( Exception ex ) {
    throw new KettleException( "Error while preparing the COPY " + copyCmd, ex );
  }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
/**** XAConnection interface ****/

    public Connection getConnection() throws SQLException
    {
        if (logger.logDebug())
            debug("PGXAConnection.getConnection called");

        Connection conn = super.getConnection();

        // When we're outside an XA transaction, autocommit
        // is supposed to be true, per usual JDBC convention.
        // When an XA transaction is in progress, it should be
        // false.
        if(state == STATE_IDLE)
            conn.setAutoCommit(true);

        /*
         * Wrap the connection in a proxy to forbid application from
         * fiddling with transaction state directly during an XA transaction
         */
        ConnectionHandler handler = new ConnectionHandler(conn);
        return (Connection)Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{Connection.class, PGConnection.class}, handler);
    }
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public void receiveChangesOccursBeforStartReplication() throws Exception {
    PGConnection pgConnection = (PGConnection) replicationConnection;

    LogSequenceNumber lsn = getCurrentLSN();

    Statement st = connection.createStatement();
    st.execute("insert into test_logical_table(name) values('previous value')");
    st.close();

    PGReplicationStream stream =
            pgConnection
                    .getReplicationAPI()
                    .replicationStream()
                    .logical()
                    .withSlotName(SLOT_NAME)
                    .withStartPosition(lsn)
                    .withSlotOption("include-xids", true)
                    .withSlotOption("skip-empty-xacts", true)
                    .withStatusInterval(20, TimeUnit.SECONDS)
                    .start();
    ByteBuffer buffer;
    while(true)
    {
        buffer = stream.readPending();
        if (buffer == null) {
            TimeUnit.MILLISECONDS.sleep(10L);
            continue;
        }

        System.out.println( toString(buffer));
        //feedback
        stream.setAppliedLSN(stream.getLastReceiveLSN());
        stream.setFlushedLSN(stream.getLastReceiveLSN());
    }

}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
/**
 * Processes notifications which may have been issued on channels that jpgAgent is listening on.
 *
 * @return
 */
private static void processNotifications() throws Exception
{
    try (final Statement statement = Database.INSTANCE.getListenerConnection().createStatement();
         final ResultSet result_set = statement.executeQuery(Config.INSTANCE.sql.getProperty("sql.jpgagent.dummy")))
    {
        Config.INSTANCE.logger.debug("Kill jobs begin.");
        final PGConnection pg_connection = Database.INSTANCE.getListenerConnection().unwrap(PGConnection.class);
        final PGNotification notifications[] = pg_connection.getNotifications();

        if (null != notifications)
        {
            for (PGNotification notification : notifications)
            {
                if (notification.getName().equals("jpgagent_kill_job"))
                {
                    int job_id = Integer.valueOf(notification.getParameter());
                    if (job_future_map.containsKey(job_id))
                    {
                        Config.INSTANCE.logger.info("Killing job_id: {}.", job_id);
                        job_future_map.get(job_id).cancel(true);
                    }
                    else
                    {
                        Config.INSTANCE.logger.info("Kill request for job_id: {} was submitted, but the job was not running.", job_id);
                    }
                }
            }
        }
    }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public void write(List<TEntity> entities) throws Exception {
    // Obtain a new Connection and execute it in a try with resources block, so it gets closed properly:
    try(Connection connection = connectionFactory.invoke()) {
        // Now get the underlying PGConnection for the COPY API wrapping:
        final PGConnection pgConnection = PostgreSqlUtils.getPGConnection(connection);
        // And finally save all entities by using the COPY API:
        client.saveAll(pgConnection, entities.stream());
    }
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public static PGConnection getPGConnection(final Connection connection) throws SQLException {
    OutParameter<PGConnection> result = new OutParameter<>();
    if(!tryGetPGConnection(connection, result)) {
        throw new PgConnectionException("Could not obtain a PGConnection");
    }
    return result.get();
}
 

import org.postgresql.PGConnection; //导入依赖的package包/类
public static boolean tryGetPGConnection(final Connection connection, OutParameter<PGConnection> result) throws SQLException {
    if(tryCastConnection(connection, result)) {
        return true;
    }
    if(tryUnwrapConnection(connection, result)) {
        return true;
    }
    return false;
}