diff --git a/build.xml b/build.xml
index c9c5660..e34f85f 100644
--- a/build.xml
+++ b/build.xml
@@ -132,6 +132,7 @@
        <include name="${package}/fastpath/**" />
        <include name="${package}/geometric/**" />
        <include name="${package}/largeobject/**" />
+       <include name="${package}/hostchooser/**" />
        <include name="${package}/util/**" />
 
        <!--      
diff --git a/org/postgresql/Driver.java.in b/org/postgresql/Driver.java.in
index f6c69c0..3f9eacc 100644
--- a/org/postgresql/Driver.java.in
+++ b/org/postgresql/Driver.java.in
@@ -465,7 +465,14 @@
                 { "kerberosServerName", Boolean.FALSE,
                   "The Kerberos service name to use when authenticating with GSSAPI.  This is equivalent to libpq's PGKRBSRVNAME environment variable." },
                 { "jaasApplicationName", Boolean.FALSE,
-                  "Specifies the name of the JAAS system or application login configuration." }
+                  "Specifies the name of the JAAS system or application login configuration." },
+                { "targetServerType", Boolean.FALSE,
+                  "Specifies what kind of server to connect.",
+                  new String[] { "any", "master", "slave", "slavefirst"  } },
+                { "enableLoadBalance", Boolean.FALSE,
+                  "Enable or disable load balance when multiple hosts were specified;If load balance is enabled,specified multiple hosts will be picked up randomly."},
+                { "failedHostCheckPeriod", Boolean.FALSE,
+                  "Specifies period(seconds) to check whether the failed hosts had been repaired, when load balance is enabled; 0 means never check." }
             };
 
     /**
diff --git a/org/postgresql/core/v2/ConnectionFactoryImpl.java b/org/postgresql/core/v2/ConnectionFactoryImpl.java
index a0cfc96..7935cc4 100644
--- a/org/postgresql/core/v2/ConnectionFactoryImpl.java
+++ b/org/postgresql/core/v2/ConnectionFactoryImpl.java
@@ -8,6 +8,7 @@
 */
 package org.postgresql.core.v2;
 
+import java.util.Iterator;
 import java.util.Properties;
 import java.util.StringTokenizer;
 
@@ -17,6 +18,9 @@
 import java.net.ConnectException;
 
 import org.postgresql.core.*;
+import org.postgresql.hostchooser.HostChooser;
+import org.postgresql.hostchooser.HostChooserFactory;
+import org.postgresql.hostchooser.HostStatus;
 import org.postgresql.util.PSQLException;
 import org.postgresql.util.PSQLState;
 import org.postgresql.util.UnixCrypt;
@@ -69,9 +73,20 @@
 
         //  - the TCP keep alive setting
         boolean requireTCPKeepAlive = (Boolean.valueOf(info.getProperty("tcpKeepAlive")).booleanValue());
+        
+        //  - the targetServerType setting
+        String targetServerType = info.getProperty("targetServerType","any").toLowerCase();
+        if (!"any".equals(targetServerType) && 
+                !"master".equals(targetServerType) && 
+                !"slave".equals(targetServerType) && 
+                !"slavefirst".equals(targetServerType)){
+            throw new PSQLException (GT.tr("Invalid targetServerType value: {0}", targetServerType), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+        }
 
-        for (int whichHost = 0; whichHost < hostSpecs.length; ++whichHost) {
-            HostSpec hostSpec = hostSpecs[whichHost];
+        HostChooser hostChooser = HostChooserFactory.createHostChooser(hostSpecs, info);
+        Iterator<HostSpec> hostIter = hostChooser.iterator();
+        while(hostIter.hasNext()) {
+            HostSpec hostSpec = hostIter.next();
             if (logger.logDebug())
                 logger.debug("Trying to establish a protocol version 2 connection to " + hostSpec);
 
@@ -115,6 +130,41 @@
             ProtocolConnectionImpl protoConnection = new ProtocolConnectionImpl(newStream, user, database, logger);
             readStartupMessages(newStream, protoConnection, logger);
 
+            // Check Master or Slaver
+            if(targetServerType.equals("any")){
+                hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectOK);
+            }else if(targetServerType.equals("master")){
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                    protoConnection.close();
+                    if (hostIter.hasNext()) {
+                        // still more addresses to try
+                        continue;
+                    }
+                    throw new PSQLException (GT.tr("Couldn't find a server with specified targetServerType: {0}", targetServerType) , PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                }
+            }else if(targetServerType.equals("slave")){
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                    protoConnection.close();
+                    if (hostIter.hasNext()) {
+                        // still more addresses to try
+                        continue;
+                    }
+                    throw new PSQLException (GT.tr("Couldn't find a server with specified targetServerType: {0}", targetServerType) , PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                }
+            }else{//slaveFirst
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                }
+            }
+            
             // Run some initial queries
             runInitialQueries(protoConnection, info, logger);
 
@@ -127,7 +177,8 @@
             // ConnectException is thrown when the connection cannot be made.
             // we trap this an return a more meaningful message for the end user
 
-            if (whichHost + 1 < hostSpecs.length) {
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -146,7 +197,8 @@
                 }
             }
 
-            if (whichHost + 1 < hostSpecs.length) {
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -165,7 +217,8 @@
                 }
             }
 
-            if (whichHost + 1 < hostSpecs.length) {
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -401,7 +454,7 @@
             }
         }
     }
-
+    
     private void runInitialQueries(ProtocolConnectionImpl protoConnection, Properties info, Logger logger) throws SQLException, IOException {
         byte[][] results = SetupQueryRunner.run(protoConnection, "set datestyle = 'ISO'; select version(), case when pg_encoding_to_char(1) = 'SQL_ASCII' then 'UNKNOWN' else getdatabaseencoding() end", true);
 
@@ -485,4 +538,11 @@
             SetupQueryRunner.run(protoConnection, sb.toString(), false);
         }
     }
+    
+
+    private boolean isMaster(ProtocolConnectionImpl protoConnection, Logger logger)throws SQLException, IOException {
+        byte[][] results = SetupQueryRunner.run(protoConnection, "show transaction_read_only", true);
+        String value = protoConnection.getEncoding().decode(results[0]);
+        return value.equalsIgnoreCase("off");
+    }
 }
diff --git a/org/postgresql/core/v3/ConnectionFactoryImpl.java b/org/postgresql/core/v3/ConnectionFactoryImpl.java
index 95eaa43..b4f4b0b 100644
--- a/org/postgresql/core/v3/ConnectionFactoryImpl.java
+++ b/org/postgresql/core/v3/ConnectionFactoryImpl.java
@@ -8,6 +8,7 @@
 */
 package org.postgresql.core.v3;
 
+import java.util.Iterator;
 import java.util.Properties;
 import java.util.TimeZone;
 
@@ -16,6 +17,9 @@
 import java.net.ConnectException;
 
 import org.postgresql.core.*;
+import org.postgresql.hostchooser.HostChooser;
+import org.postgresql.hostchooser.HostChooserFactory;
+import org.postgresql.hostchooser.HostStatus;
 import org.postgresql.util.PSQLException;
 import org.postgresql.util.PSQLState;
 import org.postgresql.util.PSQLWarning;
@@ -78,6 +82,15 @@
         //  - the TCP keep alive setting
         boolean requireTCPKeepAlive = (Boolean.valueOf(info.getProperty("tcpKeepAlive")).booleanValue());
 
+        //  - the targetServerType setting
+        String targetServerType = info.getProperty("targetServerType","any").toLowerCase();
+        if (!"any".equals(targetServerType) && 
+                !"master".equals(targetServerType) && 
+                !"slave".equals(targetServerType) && 
+                !"slavefirst".equals(targetServerType)){
+            throw new PSQLException (GT.tr("Invalid targetServerType value: {0}", targetServerType), PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+        }
+        
         // NOTE: To simplify this code, it is assumed that if we are
         // using the V3 protocol, then the database is at least 7.4.  That
         // eliminates the need to check database versions and maintain
@@ -85,8 +98,10 @@
         //
         // Change by Chris Smith <cdsmith@twu.net>
 
-        for (int whichHost = 0; whichHost < hostSpecs.length; ++whichHost) {
-            HostSpec hostSpec = hostSpecs[whichHost];
+        HostChooser hostChooser = HostChooserFactory.createHostChooser(hostSpecs, info);
+        Iterator<HostSpec> hostIter = hostChooser.iterator();
+        while(hostIter.hasNext()) {
+            HostSpec hostSpec = hostIter.next();
             
         if (logger.logDebug())
             logger.debug("Trying to establish a protocol version 3 connection to " + hostSpec);
@@ -176,8 +191,43 @@
             ProtocolConnectionImpl protoConnection = new ProtocolConnectionImpl(newStream, user, database, info, logger);
             readStartupMessages(newStream, protoConnection, logger);
 
+            // Check Master or Slaver
+            if(targetServerType.equals("any")){
+                hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectOK);
+            }else if(targetServerType.equals("master")){
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                    protoConnection.close();
+                    if (hostIter.hasNext()) {
+                        // still more addresses to try
+                        continue;
+                    }
+                    throw new PSQLException (GT.tr("Couldn't find a server with specified targetServerType: {0}", targetServerType) , PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                }
+            }else if(targetServerType.equals("slave")){
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                    protoConnection.close();
+                    if (hostIter.hasNext()) {
+                        // still more addresses to try
+                        continue;
+                    }
+                    throw new PSQLException (GT.tr("Couldn't find a server with specified targetServerType: {0}", targetServerType) , PSQLState.CONNECTION_UNABLE_TO_CONNECT);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                }
+            }else{//slaveFirst
+                if(isMaster(protoConnection, logger)){
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Master);
+                }else{
+                    hostChooser.reportHostStatus(hostSpec, HostStatus.Slave);
+                }
+            }
+            
             runInitialQueries(protoConnection, info, logger);
-
+            
             // And we're done.
             return protoConnection;
         }
@@ -193,6 +243,7 @@
             catch (IOException e)
             {
             }
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
             return null;
         }
         catch (ConnectException cex)
@@ -200,7 +251,9 @@
             // Added by Peter Mount <peter@retep.org.uk>
             // ConnectException is thrown when the connection cannot be made.
             // we trap this an return a more meaningful message for the end user
-            if (whichHost + 1 < hostSpecs.length) {
+            
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -218,7 +271,8 @@
                 {
                 }
             }
-            if (whichHost + 1 < hostSpecs.length) {
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -236,7 +290,8 @@
                 {
                 }
             }
-            if (whichHost + 1 < hostSpecs.length) {
+            hostChooser.reportHostStatus(hostSpec, HostStatus.ConnectFail);
+            if (hostIter.hasNext()) {
                 // still more addresses to try
                 continue;
             }
@@ -646,5 +701,11 @@
         }
 
     }
+    
+    private boolean isMaster(ProtocolConnectionImpl protoConnection, Logger logger)throws SQLException, IOException {
+        byte[][] results = SetupQueryRunner.run(protoConnection, "show transaction_read_only", true);
+        String value = protoConnection.getEncoding().decode(results[0]);
+        return value.equalsIgnoreCase("off");
+    }
 
 }
diff --git a/org/postgresql/ds/common/BaseDataSource.java b/org/postgresql/ds/common/BaseDataSource.java
index bfe54f7..0a00e69 100644
--- a/org/postgresql/ds/common/BaseDataSource.java
+++ b/org/postgresql/ds/common/BaseDataSource.java
@@ -63,6 +63,9 @@
     private int logLevel = 0;
     private int protocolVersion = 0;
     private String applicationName;
+    private String targetServerType;
+    private boolean enableLoadBalance = false;
+    private int failedHostCheckPeriod = -1;
 
     /**
      * Gets a connection to the PostgreSQL database.  The database is identified by the
@@ -397,7 +400,37 @@
     {
         return applicationName;
     }
+    
+    public void setTargetServerType(String targetServerType)
+    {
+        this.targetServerType = targetServerType;
+    }
+    
+    public String getTargetServerType()
+    {
+        return targetServerType;
+    }
+    
+    public void setEnableLoadBalance(boolean enableLoadBalance)
+    {
+        this.enableLoadBalance = enableLoadBalance;
+    }
 
+    public boolean getEnableLoadBalance()
+    {
+        return enableLoadBalance;
+    }
+    
+    public void setFailedHostCheckPeriod(int failedHostCheckPeriod)
+    {
+        this.failedHostCheckPeriod = failedHostCheckPeriod;
+    }
+
+    public int getFailedHostCheckPeriod()
+    {
+        return failedHostCheckPeriod;
+    }
+    
     public void setTcpKeepAlive(boolean enabled)
     {
         tcpKeepAlive = enabled;
@@ -513,6 +546,16 @@
         if (binaryTransfer) {
         	sb.append("&binaryTransfer=true");
         }
+        if (targetServerType != null) {
+            sb.append("&targetServerType=");
+            sb.append(targetServerType);
+        }
+        if (enableLoadBalance) {
+            sb.append("&enableLoadBalance=true");
+        }
+        if (failedHostCheckPeriod != -1) {
+            sb.append("&failedHostCheckPeriod=").append(failedHostCheckPeriod);
+        }
 
         return sb.toString();
     }
@@ -565,6 +608,10 @@
         ref.add(new StringRefAddr("logLevel", Integer.toString(logLevel)));
         ref.add(new StringRefAddr("protocolVersion", Integer.toString(protocolVersion)));
         ref.add(new StringRefAddr("ApplicationName", applicationName));
+        
+        ref.add(new StringRefAddr("targetServerType", targetServerType));
+        ref.add(new StringRefAddr("enableLoadBalance", Boolean.toString(enableLoadBalance)));
+        ref.add(new StringRefAddr("failedHostCheckPeriod", Integer.toString(failedHostCheckPeriod)));
 
         return ref;
     }
@@ -592,6 +639,9 @@
         out.writeBoolean(binaryTransfer);
         out.writeObject(binaryTransferEnable);
         out.writeObject(binaryTransferDisable);
+        out.writeObject(targetServerType);
+        out.writeBoolean(enableLoadBalance);
+        out.writeInt(failedHostCheckPeriod);
     }
 
     protected void readBaseObject(ObjectInputStream in) throws IOException, ClassNotFoundException
@@ -617,6 +667,9 @@
         binaryTransfer = in.readBoolean();
         binaryTransferEnable = (String)in.readObject();
         binaryTransferDisable = (String)in.readObject();
+        targetServerType = (String)in.readObject();
+        enableLoadBalance = in.readBoolean();
+        failedHostCheckPeriod = in.readInt();
     }
 
     public void initializeFrom(BaseDataSource source) throws IOException, ClassNotFoundException {
diff --git a/org/postgresql/hostchooser/HostChooser.java b/org/postgresql/hostchooser/HostChooser.java
new file mode 100644
index 0000000..fa1e1a9
--- /dev/null
+++ b/org/postgresql/hostchooser/HostChooser.java
@@ -0,0 +1,16 @@
+/**
+ * 
+ */
+package org.postgresql.hostchooser;
+
+import java.util.Iterator;
+
+import org.postgresql.util.HostSpec;
+
+/**
+ *
+ */
+public interface HostChooser {
+    Iterator<HostSpec> iterator();
+    void reportHostStatus(HostSpec hostSpec, HostStatus hostStatus);
+}
diff --git a/org/postgresql/hostchooser/HostChooserFactory.java b/org/postgresql/hostchooser/HostChooserFactory.java
new file mode 100644
index 0000000..0cf4461
--- /dev/null
+++ b/org/postgresql/hostchooser/HostChooserFactory.java
@@ -0,0 +1,26 @@
+/**
+ * 
+ */
+package org.postgresql.hostchooser;
+
+import java.util.Properties;
+import org.postgresql.util.HostSpec;
+
+/**
+ *
+ */
+public class HostChooserFactory {
+
+    public static HostChooser createHostChooser(HostSpec[] hostSpecs,Properties info){
+        
+        if(hostSpecs.length==1){
+            return new SingleHostChooser(hostSpecs[0]);
+        }
+        
+        if (Boolean.valueOf(info.getProperty("enableLoadBalance","false")).booleanValue()){
+            return new LoadBalanceHostChooser(hostSpecs,info);
+        }
+        
+        return new LastKnownGoodHostChooser(hostSpecs,info);
+        }
+}
diff --git a/org/postgresql/hostchooser/HostChooserWithStatusReport.java b/org/postgresql/hostchooser/HostChooserWithStatusReport.java
new file mode 100644
index 0000000..f0756b4
--- /dev/null
+++ b/org/postgresql/hostchooser/HostChooserWithStatusReport.java
@@ -0,0 +1,48 @@
+package org.postgresql.hostchooser;
+
+import java.util.HashMap;
+
+import org.postgresql.util.*;
+
+/*
+ * Abstract class which implements host status reporting
+ * 
+ * @author Chen Huajun (chenhj@cn.fujitsu.com)
+ */
+public abstract class HostChooserWithStatusReport implements HostChooser
+{
+    private static volatile HashMap<String,HostStatus> hostStatusCache = new HashMap<String,HostStatus>();
+    
+    protected HashMap<String,HostStatus> hostStatusMap = (HashMap<String, HostStatus>) hostStatusCache.clone();
+    
+    public void reportHostStatus(HostSpec hostSpec, HostStatus hostStatus) {
+        reportHostStatus(hostSpec.toString(),hostStatus);
+      }
+    
+    private boolean needUpdateHostStatus(HostStatus oldHostStatus,HostStatus newHostStatus){
+        if(oldHostStatus == newHostStatus)
+            return false;
+        
+        if(newHostStatus == HostStatus.ConnectOK){
+            if(oldHostStatus == HostStatus.Master ||
+                    oldHostStatus == HostStatus.Slave)
+                return false;
+        }
+        
+        return true;
+    }
+    
+    public void reportHostStatus(String hostSpecKey, HostStatus hostStatus) {
+        HostStatus oldHostStatus = hostStatusCache.get(hostSpecKey);
+        if(needUpdateHostStatus(oldHostStatus, hostStatus)) {
+            synchronized(HostChooserWithStatusReport.class){
+                oldHostStatus = hostStatusCache.get(hostSpecKey);
+                if(needUpdateHostStatus(oldHostStatus, hostStatus)) {
+                    HashMap<String,HostStatus> newHostStatusMap = (HashMap<String, HostStatus>) hostStatusCache.clone();
+                    newHostStatusMap.put(hostSpecKey, hostStatus);
+                    hostStatusCache=newHostStatusMap;
+                }
+            }
+        }
+      }
+}
\ No newline at end of file
diff --git a/org/postgresql/hostchooser/HostStatus.java b/org/postgresql/hostchooser/HostStatus.java
new file mode 100644
index 0000000..42ba31c
--- /dev/null
+++ b/org/postgresql/hostchooser/HostStatus.java
@@ -0,0 +1,14 @@
+/**
+ * 
+ */
+package org.postgresql.hostchooser;
+
+/**
+ *
+ */
+public enum HostStatus {
+    ConnectOK,
+    ConnectFail,
+    Master,
+    Slave
+}
diff --git a/org/postgresql/hostchooser/LastKnownGoodHostChooser.java b/org/postgresql/hostchooser/LastKnownGoodHostChooser.java
new file mode 100644
index 0000000..158757c
--- /dev/null
+++ b/org/postgresql/hostchooser/LastKnownGoodHostChooser.java
@@ -0,0 +1,75 @@
+package org.postgresql.hostchooser;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Properties;
+
+import org.postgresql.util.*;
+
+/*
+ * Pick up one known good host first and then try others
+ * 
+ * @author Chen Huajun (chenhj@cn.fujitsu.com)
+ */
+public class LastKnownGoodHostChooser extends HostChooserWithStatusReport
+{
+  private final HostSpec[] hostSpecs;
+  private String targetServerType;
+  
+  public LastKnownGoodHostChooser(HostSpec[] hostSpecs,Properties info) {
+      this.hostSpecs = hostSpecs;
+      targetServerType = info.getProperty("targetServerType", "any").toLowerCase();
+  }
+
+  public Iterator<HostSpec> iterator() {
+    int first = -1;
+    for (int i = 0; i < hostSpecs.length; i++) {
+        HostStatus hostStatus = hostStatusMap.get(hostSpecs[i].toString());
+        if(hostStatus != null){   
+            if(targetServerType.equals("any") && hostStatus != HostStatus.ConnectFail){
+                first = i;
+                break;
+            }
+            
+            if(targetServerType.equals("master") && hostStatus == HostStatus.Master){
+                first = i;
+                break;
+            }
+            
+            if((targetServerType.equals("slave") || targetServerType.equals("slavefirst")) && 
+                    hostStatus == HostStatus.Slave){
+                first = i;
+                break;
+            }
+        }
+      }
+    
+    if(first == -1 && targetServerType.equals("slavefirst")){
+        for (int i = 0; i < hostSpecs.length; i++) {
+            HostStatus hostStatus = hostStatusMap.get(hostSpecs[i].toString());
+            if(hostStatus != null){   
+                if(hostStatus != HostStatus.ConnectFail){
+                    first = i;
+                    break;
+                }
+            }
+          }
+    }
+    
+    if (first == -1 ) {
+        first = 0;
+    }
+    
+    ArrayList<HostSpec> reordered = new ArrayList<HostSpec>(hostSpecs.length);
+    for (int i = first; i < hostSpecs.length; i++) {
+      reordered.add(hostSpecs[i]);
+    }
+    
+    for (int i = 0; i < first; i++) {
+      reordered.add(hostSpecs[i]);
+    }
+    
+    return reordered.iterator();
+  }
+
+}
\ No newline at end of file
diff --git a/org/postgresql/hostchooser/LoadBalanceHostChooser.java b/org/postgresql/hostchooser/LoadBalanceHostChooser.java
new file mode 100644
index 0000000..1586e54
--- /dev/null
+++ b/org/postgresql/hostchooser/LoadBalanceHostChooser.java
@@ -0,0 +1,116 @@
+package org.postgresql.hostchooser;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.Properties;
+
+import org.postgresql.util.*;
+
+/*
+ * Pick up one from known good hosts randomly first and then try others
+ * 
+ * @author Chen Huajun (chenhj@cn.fujitsu.com)
+ */
+public class LoadBalanceHostChooser extends HostChooserWithStatusReport
+{
+  private final HostSpec[] hostSpecs;
+  private String targetServerType;
+  private int failedHostCheckPeriod;
+  private static long lastfailedHostCheckTime = new Date().getTime();
+  
+  public LoadBalanceHostChooser(HostSpec[] hostSpecs,Properties info) {
+      this.hostSpecs = hostSpecs;
+      targetServerType = info.getProperty("targetServerType", "any").toLowerCase();
+      failedHostCheckPeriod = Integer.parseInt(info.getProperty("failedHostCheckPeriod", "600"))*1000;
+  }
+
+  public Iterator<HostSpec> iterator() {
+      long now = new Date().getTime();
+      if(failedHostCheckPeriod >0 && now > lastfailedHostCheckTime + failedHostCheckPeriod)
+      {
+          int connectFailCount = 0;
+          Iterator<String> iter = hostStatusMap.keySet().iterator();
+          while(iter.hasNext()){
+              String key = iter.next();
+              if(hostStatusMap.get(key) == HostStatus.ConnectFail){
+                  connectFailCount++;
+              }
+          }
+          
+          if(connectFailCount > 0)
+          {
+          synchronized(HostChooserWithStatusReport.class){
+              if(now > lastfailedHostCheckTime + failedHostCheckPeriod)
+              {
+                  iter = hostStatusMap.keySet().iterator();
+                  while(iter.hasNext()){
+                      String key = iter.next();
+                      if(hostStatusMap.get(key) == HostStatus.ConnectFail){
+                          reportHostStatus(key, null);
+                      }
+                  }
+                  lastfailedHostCheckTime = now;
+              }
+          }
+          }
+      }
+      
+    ArrayList<HostSpec> reordered = new ArrayList<HostSpec>(hostSpecs.length);
+    ArrayList<HostSpec> rest = new ArrayList<HostSpec>(hostSpecs.length);
+    for (int i = 0; i < hostSpecs.length; i++) {
+        rest.add(hostSpecs[i]);
+        HostStatus hostStatus = hostStatusMap.get(hostSpecs[i].toString());
+        if(hostStatus != null){
+            if(targetServerType.equals("any") && hostStatus != HostStatus.ConnectFail){
+                reordered.add(hostSpecs[i]);
+                rest.remove(rest.size()-1);
+                continue;
+            }
+            
+            if(targetServerType.equals("master") && hostStatus == HostStatus.Master){
+                reordered.add(hostSpecs[i]);
+                rest.remove(rest.size()-1);
+                continue;
+            }
+            
+            if((targetServerType.equals("slave") || targetServerType.equals("slavefirst")) && 
+                    hostStatus == HostStatus.Slave){
+                reordered.add(hostSpecs[i]);
+                rest.remove(rest.size()-1);
+                continue;
+            }
+        }else{
+            reordered.add(hostSpecs[i]);
+            rest.remove(rest.size()-1);
+            continue;
+        }
+      }
+    
+    if(reordered.size() == 0 && targetServerType.equals("slavefirst")){
+        for (int i = 0; i < hostSpecs.length; i++) {
+            HostStatus hostStatus = hostStatusMap.get(hostSpecs[i].toString());
+            if(hostStatus != null){   
+                if(hostStatus != HostStatus.ConnectFail){
+                    reordered.add(hostSpecs[i]);
+                    rest.remove(hostSpecs[i]);
+                }
+            }
+          }
+    }
+    
+    if (reordered.size() > 0) {
+        int first = (int)(Math.random() * reordered.size());
+        HostSpec tmpHostSpec=reordered.get(0);
+        reordered.set(0, reordered.get(first));
+        reordered.set(first,tmpHostSpec);
+    }
+    
+    for (int i = 0; i < rest.size(); i++) {
+        reordered.add(rest.get(i));
+    }
+    
+    return reordered.iterator();
+  }
+
+}
\ No newline at end of file
diff --git a/org/postgresql/hostchooser/SingleHostChooser.java b/org/postgresql/hostchooser/SingleHostChooser.java
new file mode 100644
index 0000000..08635b8
--- /dev/null
+++ b/org/postgresql/hostchooser/SingleHostChooser.java
@@ -0,0 +1,21 @@
+package org.postgresql.hostchooser;
+
+import java.util.Collections;
+import java.util.Iterator;
+
+import org.postgresql.util.*;
+
+public class SingleHostChooser implements HostChooser {
+    private final HostSpec hostSpec;
+
+    public SingleHostChooser(HostSpec hostSpec) {
+        this.hostSpec = hostSpec;
+    }
+
+    public Iterator<HostSpec> iterator() {
+        return Collections.singletonList(hostSpec).iterator();
+    }
+
+    public void reportHostStatus(HostSpec hostSpec, HostStatus hostStatus) {
+    }
+}
\ No newline at end of file