pg 8.2.1 → 8.3.3

package/lib/client.js

@@ -1,11 +1,4 @@
 'use strict'
-/**
- * Copyright (c) 2010-2017 Brian Carlson (brian.m.carlson@gmail.com)
- * All rights reserved.
- *
- * This source code is licensed under the MIT license found in the
- * README.md file in the root directory of this source tree.
- */
 
 var EventEmitter = require('events').EventEmitter
 var util = require('util')
@@ -19,573 +12,590 @@ var Query = require('./query')
 var defaults = require('./defaults')
 var Connection = require('./connection')
 
-var Client = function (config) {
-  EventEmitter.call(this)
-
-  this.connectionParameters = new ConnectionParameters(config)
-  this.user = this.connectionParameters.user
-  this.database = this.connectionParameters.database
-  this.port = this.connectionParameters.port
-  this.host = this.connectionParameters.host
-
-  // "hiding" the password so it doesn't show up in stack traces
-  // or if the client is console.logged
-  Object.defineProperty(this, 'password', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: this.connectionParameters.password,
-  })
-
-  this.replication = this.connectionParameters.replication
-
-  var c = config || {}
-
-  this._Promise = c.Promise || global.Promise
-  this._types = new TypeOverrides(c.types)
-  this._ending = false
-  this._connecting = false
-  this._connected = false
-  this._connectionError = false
-  this._queryable = true
-
-  this.connection =
-    c.connection ||
-    new Connection({
-      stream: c.stream,
-      ssl: this.connectionParameters.ssl,
-      keepAlive: c.keepAlive || false,
-      keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
-      encoding: this.connectionParameters.client_encoding || 'utf8',
+class Client extends EventEmitter {
+  constructor(config) {
+    super()
+
+    this.connectionParameters = new ConnectionParameters(config)
+    this.user = this.connectionParameters.user
+    this.database = this.connectionParameters.database
+    this.port = this.connectionParameters.port
+    this.host = this.connectionParameters.host
+
+    // "hiding" the password so it doesn't show up in stack traces
+    // or if the client is console.logged
+    Object.defineProperty(this, 'password', {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value: this.connectionParameters.password,
     })
-  this.queryQueue = []
-  this.binary = c.binary || defaults.binary
-  this.processID = null
-  this.secretKey = null
-  this.ssl = this.connectionParameters.ssl || false
-  this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0
-}
-
-util.inherits(Client, EventEmitter)
 
-Client.prototype._errorAllQueries = function (err) {
-  const enqueueError = (query) => {
-    process.nextTick(() => {
-      query.handleError(err, this.connection)
-    })
+    this.replication = this.connectionParameters.replication
+
+    var c = config || {}
+
+    this._Promise = c.Promise || global.Promise
+    this._types = new TypeOverrides(c.types)
+    this._ending = false
+    this._connecting = false
+    this._connected = false
+    this._connectionError = false
+    this._queryable = true
+
+    this.connection =
+      c.connection ||
+      new Connection({
+        stream: c.stream,
+        ssl: this.connectionParameters.ssl,
+        keepAlive: c.keepAlive || false,
+        keepAliveInitialDelayMillis: c.keepAliveInitialDelayMillis || 0,
+        encoding: this.connectionParameters.client_encoding || 'utf8',
+      })
+    this.queryQueue = []
+    this.binary = c.binary || defaults.binary
+    this.processID = null
+    this.secretKey = null
+    this.ssl = this.connectionParameters.ssl || false
+    this._connectionTimeoutMillis = c.connectionTimeoutMillis || 0
   }
 
-  if (this.activeQuery) {
-    enqueueError(this.activeQuery)
-    this.activeQuery = null
+  _errorAllQueries(err) {
+    const enqueueError = (query) => {
+      process.nextTick(() => {
+        query.handleError(err, this.connection)
+      })
+    }
+
+    if (this.activeQuery) {
+      enqueueError(this.activeQuery)
+      this.activeQuery = null
+    }
+
+    this.queryQueue.forEach(enqueueError)
+    this.queryQueue.length = 0
   }
 
-  this.queryQueue.forEach(enqueueError)
-  this.queryQueue.length = 0
-}
+  _connect(callback) {
+    var self = this
+    var con = this.connection
+    this._connectionCallback = callback
+
+    if (this._connecting || this._connected) {
+      const err = new Error('Client has already been connected. You cannot reuse a client.')
+      process.nextTick(() => {
+        callback(err)
+      })
+      return
+    }
+    this._connecting = true
+
+    this.connectionTimeoutHandle
+    if (this._connectionTimeoutMillis > 0) {
+      this.connectionTimeoutHandle = setTimeout(() => {
+        con._ending = true
+        con.stream.destroy(new Error('timeout expired'))
+      }, this._connectionTimeoutMillis)
+    }
+
+    if (this.host && this.host.indexOf('/') === 0) {
+      con.connect(this.host + '/.s.PGSQL.' + this.port)
+    } else {
+      con.connect(this.port, this.host)
+    }
+
+    // once connection is established send startup message
+    con.on('connect', function () {
+      if (self.ssl) {
+        con.requestSsl()
+      } else {
+        con.startup(self.getStartupConf())
+      }
+    })
+
+    con.on('sslconnect', function () {
+      con.startup(self.getStartupConf())
+    })
+
+    this._attachListeners(con)
 
-Client.prototype._connect = function (callback) {
-  var self = this
-  var con = this.connection
-  if (this._connecting || this._connected) {
-    const err = new Error('Client has already been connected. You cannot reuse a client.')
-    process.nextTick(() => {
-      callback(err)
+    con.once('end', () => {
+      const error = this._ending ? new Error('Connection terminated') : new Error('Connection terminated unexpectedly')
+
+      clearTimeout(this.connectionTimeoutHandle)
+      this._errorAllQueries(error)
+
+      if (!this._ending) {
+        // if the connection is ended without us calling .end()
+        // on this client then we have an unexpected disconnection
+        // treat this as an error unless we've already emitted an error
+        // during connection.
+        if (this._connecting && !this._connectionError) {
+          if (this._connectionCallback) {
+            this._connectionCallback(error)
+          } else {
+            this._handleErrorEvent(error)
+          }
+        } else if (!this._connectionError) {
+          this._handleErrorEvent(error)
+        }
+      }
+
+      process.nextTick(() => {
+        this.emit('end')
+      })
     })
-    return
   }
-  this._connecting = true
 
-  var connectionTimeoutHandle
-  if (this._connectionTimeoutMillis > 0) {
-    connectionTimeoutHandle = setTimeout(() => {
-      con._ending = true
-      con.stream.destroy(new Error('timeout expired'))
-    }, this._connectionTimeoutMillis)
+  connect(callback) {
+    if (callback) {
+      this._connect(callback)
+      return
+    }
+
+    return new this._Promise((resolve, reject) => {
+      this._connect((error) => {
+        if (error) {
+          reject(error)
+        } else {
+          resolve()
+        }
+      })
+    })
   }
 
-  if (this.host && this.host.indexOf('/') === 0) {
-    con.connect(this.host + '/.s.PGSQL.' + this.port)
-  } else {
-    con.connect(this.port, this.host)
+  _attachListeners(con) {
+    // password request handling
+    con.on('authenticationCleartextPassword', this._handleAuthCleartextPassword.bind(this))
+    // password request handling
+    con.on('authenticationMD5Password', this._handleAuthMD5Password.bind(this))
+    // password request handling (SASL)
+    con.on('authenticationSASL', this._handleAuthSASL.bind(this))
+    con.on('authenticationSASLContinue', this._handleAuthSASLContinue.bind(this))
+    con.on('authenticationSASLFinal', this._handleAuthSASLFinal.bind(this))
+    con.on('backendKeyData', this._handleBackendKeyData.bind(this))
+    con.on('error', this._handleErrorEvent.bind(this))
+    con.on('errorMessage', this._handleErrorMessage.bind(this))
+    con.on('readyForQuery', this._handleReadyForQuery.bind(this))
+    con.on('notice', this._handleNotice.bind(this))
+    con.on('rowDescription', this._handleRowDescription.bind(this))
+    con.on('dataRow', this._handleDataRow.bind(this))
+    con.on('portalSuspended', this._handlePortalSuspended.bind(this))
+    con.on('emptyQuery', this._handleEmptyQuery.bind(this))
+    con.on('commandComplete', this._handleCommandComplete.bind(this))
+    con.on('parseComplete', this._handleParseComplete.bind(this))
+    con.on('copyInResponse', this._handleCopyInResponse.bind(this))
+    con.on('copyData', this._handleCopyData.bind(this))
+    con.on('notification', this._handleNotification.bind(this))
   }
 
-  // once connection is established send startup message
-  con.on('connect', function () {
-    if (self.ssl) {
-      con.requestSsl()
-    } else {
-      con.startup(self.getStartupConf())
-    }
-  })
-
-  con.on('sslconnect', function () {
-    con.startup(self.getStartupConf())
-  })
-
-  function checkPgPass(cb) {
-    return function (msg) {
-      if (typeof self.password === 'function') {
-        self._Promise
-          .resolve()
-          .then(() => self.password())
-          .then((pass) => {
-            if (pass !== undefined) {
-              if (typeof pass !== 'string') {
-                con.emit('error', new TypeError('Password must be a string'))
-                return
-              }
-              self.connectionParameters.password = self.password = pass
-            } else {
-              self.connectionParameters.password = self.password = null
+  // TODO(bmc): deprecate pgpass "built in" integration since this.password can be a function
+  // it can be supplied by the user if required - this is a breaking change!
+  _checkPgPass(cb) {
+    const con = this.connection
+    if (typeof this.password === 'function') {
+      this._Promise
+        .resolve()
+        .then(() => this.password())
+        .then((pass) => {
+          if (pass !== undefined) {
+            if (typeof pass !== 'string') {
+              con.emit('error', new TypeError('Password must be a string'))
+              return
             }
-            cb(msg)
-          })
-          .catch((err) => {
-            con.emit('error', err)
-          })
-      } else if (self.password !== null) {
-        cb(msg)
-      } else {
-        pgPass(self.connectionParameters, function (pass) {
-          if (undefined !== pass) {
-            self.connectionParameters.password = self.password = pass
+            this.connectionParameters.password = this.password = pass
+          } else {
+            this.connectionParameters.password = this.password = null
           }
-          cb(msg)
+          cb()
         })
-      }
+        .catch((err) => {
+          con.emit('error', err)
+        })
+    } else if (this.password !== null) {
+      cb()
+    } else {
+      pgPass(this.connectionParameters, (pass) => {
+        if (undefined !== pass) {
+          this.connectionParameters.password = this.password = pass
+        }
+        cb()
+      })
     }
   }
 
-  // password request handling
-  con.on(
-    'authenticationCleartextPassword',
-    checkPgPass(function () {
-      con.password(self.password)
+  _handleAuthCleartextPassword(msg) {
+    this._checkPgPass(() => {
+      this.connection.password(this.password)
     })
-  )
+  }
 
-  // password request handling
-  con.on(
-    'authenticationMD5Password',
-    checkPgPass(function (msg) {
-      con.password(utils.postgresMd5PasswordHash(self.user, self.password, msg.salt))
+  _handleAuthMD5Password(msg) {
+    this._checkPgPass(() => {
+      const hashedPassword = utils.postgresMd5PasswordHash(this.user, this.password, msg.salt)
+      this.connection.password(hashedPassword)
     })
-  )
-
-  // password request handling (SASL)
-  var saslSession
-  con.on(
-    'authenticationSASL',
-    checkPgPass(function (msg) {
-      saslSession = sasl.startSession(msg.mechanisms)
+  }
 
-      con.sendSASLInitialResponseMessage(saslSession.mechanism, saslSession.response)
+  _handleAuthSASL(msg) {
+    this._checkPgPass(() => {
+      this.saslSession = sasl.startSession(msg.mechanisms)
+      this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response)
     })
-  )
-
-  // password request handling (SASL)
-  con.on('authenticationSASLContinue', function (msg) {
-    sasl.continueSession(saslSession, self.password, msg.data)
+  }
 
-    con.sendSCRAMClientFinalMessage(saslSession.response)
-  })
+  _handleAuthSASLContinue(msg) {
+    sasl.continueSession(this.saslSession, this.password, msg.data)
+    this.connection.sendSCRAMClientFinalMessage(this.saslSession.response)
+  }
 
-  // password request handling (SASL)
-  con.on('authenticationSASLFinal', function (msg) {
-    sasl.finalizeSession(saslSession, msg.data)
+  _handleAuthSASLFinal(msg) {
+    sasl.finalizeSession(this.saslSession, msg.data)
+    this.saslSession = null
+  }
 
-    saslSession = null
-  })
+  _handleBackendKeyData(msg) {
+    this.processID = msg.processID
+    this.secretKey = msg.secretKey
+  }
 
-  con.once('backendKeyData', function (msg) {
-    self.processID = msg.processID
-    self.secretKey = msg.secretKey
-  })
+  _handleReadyForQuery(msg) {
+    if (this._connecting) {
+      this._connecting = false
+      this._connected = true
+      clearTimeout(this.connectionTimeoutHandle)
+
+      // process possible callback argument to Client#connect
+      if (this._connectionCallback) {
+        this._connectionCallback(null, this)
+        // remove callback for proper error handling
+        // after the connect event
+        this._connectionCallback = null
+      }
+      this.emit('connect')
+    }
+    const { activeQuery } = this
+    this.activeQuery = null
+    this.readyForQuery = true
+    if (activeQuery) {
+      activeQuery.handleReadyForQuery(this.connection)
+    }
+    this._pulseQueryQueue()
+  }
 
-  const connectingErrorHandler = (err) => {
+  // if we receieve an error event or error message
+  // during the connection process we handle it here
+  _handleErrorWhileConnecting(err) {
     if (this._connectionError) {
+      // TODO(bmc): this is swallowing errors - we shouldn't do this
       return
     }
     this._connectionError = true
-    clearTimeout(connectionTimeoutHandle)
-    if (callback) {
-      return callback(err)
+    clearTimeout(this.connectionTimeoutHandle)
+    if (this._connectionCallback) {
+      return this._connectionCallback(err)
     }
     this.emit('error', err)
   }
 
-  const connectedErrorHandler = (err) => {
+  // if we're connected and we receive an error event from the connection
+  // this means the socket is dead - do a hard abort of all queries and emit
+  // the socket error on the client as well
+  _handleErrorEvent(err) {
+    if (this._connecting) {
+      return this._handleErrorWhileConnecting(err)
+    }
     this._queryable = false
     this._errorAllQueries(err)
     this.emit('error', err)
   }
 
-  const connectedErrorMessageHandler = (msg) => {
+  // handle error messages from the postgres backend
+  _handleErrorMessage(msg) {
+    if (this._connecting) {
+      return this._handleErrorWhileConnecting(msg)
+    }
     const activeQuery = this.activeQuery
 
     if (!activeQuery) {
-      connectedErrorHandler(msg)
+      this._handleErrorEvent(msg)
       return
     }
 
     this.activeQuery = null
-    activeQuery.handleError(msg, con)
+    activeQuery.handleError(msg, this.connection)
   }
 
-  con.on('error', connectingErrorHandler)
-  con.on('errorMessage', connectingErrorHandler)
+  _handleRowDescription(msg) {
+    // delegate rowDescription to active query
+    this.activeQuery.handleRowDescription(msg)
+  }
 
-  // hook up query handling events to connection
-  // after the connection initially becomes ready for queries
-  con.once('readyForQuery', function () {
-    self._connecting = false
-    self._connected = true
-    self._attachListeners(con)
-    con.removeListener('error', connectingErrorHandler)
-    con.removeListener('errorMessage', connectingErrorHandler)
-    con.on('error', connectedErrorHandler)
-    con.on('errorMessage', connectedErrorMessageHandler)
-    clearTimeout(connectionTimeoutHandle)
+  _handleDataRow(msg) {
+    // delegate dataRow to active query
+    this.activeQuery.handleDataRow(msg)
+  }
 
-    // process possible callback argument to Client#connect
-    if (callback) {
-      callback(null, self)
-      // remove callback for proper error handling
-      // after the connect event
-      callback = null
-    }
-    self.emit('connect')
-  })
-
-  con.on('readyForQuery', function () {
-    var activeQuery = self.activeQuery
-    self.activeQuery = null
-    self.readyForQuery = true
-    if (activeQuery) {
-      activeQuery.handleReadyForQuery(con)
-    }
-    self._pulseQueryQueue()
-  })
+  _handlePortalSuspended(msg) {
+    // delegate portalSuspended to active query
+    this.activeQuery.handlePortalSuspended(this.connection)
+  }
 
-  con.once('end', () => {
-    const error = this._ending ? new Error('Connection terminated') : new Error('Connection terminated unexpectedly')
+  _handleEmptyQuery(msg) {
+    // delegate emptyQuery to active query
+    this.activeQuery.handleEmptyQuery(this.connection)
+  }
 
-    clearTimeout(connectionTimeoutHandle)
-    this._errorAllQueries(error)
+  _handleCommandComplete(msg) {
+    // delegate commandComplete to active query
+    this.activeQuery.handleCommandComplete(msg, this.connection)
+  }
 
-    if (!this._ending) {
-      // if the connection is ended without us calling .end()
-      // on this client then we have an unexpected disconnection
-      // treat this as an error unless we've already emitted an error
-      // during connection.
-      if (this._connecting && !this._connectionError) {
-        if (callback) {
-          callback(error)
-        } else {
-          connectedErrorHandler(error)
-        }
-      } else if (!this._connectionError) {
-        connectedErrorHandler(error)
-      }
+  _handleParseComplete(msg) {
+    // if a prepared statement has a name and properly parses
+    // we track that its already been executed so we don't parse
+    // it again on the same client
+    if (this.activeQuery.name) {
+      this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text
     }
-
-    process.nextTick(() => {
-      this.emit('end')
-    })
-  })
-
-  con.on('notice', function (msg) {
-    self.emit('notice', msg)
-  })
-}
-
-Client.prototype.connect = function (callback) {
-  if (callback) {
-    this._connect(callback)
-    return
   }
 
-  return new this._Promise((resolve, reject) => {
-    this._connect((error) => {
-      if (error) {
-        reject(error)
-      } else {
-        resolve()
-      }
-    })
-  })
-}
-
-Client.prototype._attachListeners = function (con) {
-  const self = this
-  // delegate rowDescription to active query
-  con.on('rowDescription', function (msg) {
-    self.activeQuery.handleRowDescription(msg)
-  })
-
-  // delegate dataRow to active query
-  con.on('dataRow', function (msg) {
-    self.activeQuery.handleDataRow(msg)
-  })
-
-  // delegate portalSuspended to active query
-  // eslint-disable-next-line no-unused-vars
-  con.on('portalSuspended', function (msg) {
-    self.activeQuery.handlePortalSuspended(con)
-  })
-
-  // delegate emptyQuery to active query
-  // eslint-disable-next-line no-unused-vars
-  con.on('emptyQuery', function (msg) {
-    self.activeQuery.handleEmptyQuery(con)
-  })
-
-  // delegate commandComplete to active query
-  con.on('commandComplete', function (msg) {
-    self.activeQuery.handleCommandComplete(msg, con)
-  })
-
-  // if a prepared statement has a name and properly parses
-  // we track that its already been executed so we don't parse
-  // it again on the same client
-  // eslint-disable-next-line no-unused-vars
-  con.on('parseComplete', function (msg) {
-    if (self.activeQuery.name) {
-      con.parsedStatements[self.activeQuery.name] = self.activeQuery.text
-    }
-  })
-
-  // eslint-disable-next-line no-unused-vars
-  con.on('copyInResponse', function (msg) {
-    self.activeQuery.handleCopyInResponse(self.connection)
-  })
-
-  con.on('copyData', function (msg) {
-    self.activeQuery.handleCopyData(msg, self.connection)
-  })
-
-  con.on('notification', function (msg) {
-    self.emit('notification', msg)
-  })
-}
-
-Client.prototype.getStartupConf = function () {
-  var params = this.connectionParameters
-
-  var data = {
-    user: params.user,
-    database: params.database,
+  _handleCopyInResponse(msg) {
+    this.activeQuery.handleCopyInResponse(this.connection)
   }
 
-  var appName = params.application_name || params.fallback_application_name
-  if (appName) {
-    data.application_name = appName
-  }
-  if (params.replication) {
-    data.replication = '' + params.replication
+  _handleCopyData(msg) {
+    this.activeQuery.handleCopyData(msg, this.connection)
   }
-  if (params.statement_timeout) {
-    data.statement_timeout = String(parseInt(params.statement_timeout, 10))
+
+  _handleNotification(msg) {
+    this.emit('notification', msg)
   }
-  if (params.idle_in_transaction_session_timeout) {
-    data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10))
+
+  _handleNotice(msg) {
+    this.emit('notice', msg)
   }
 
-  return data
-}
+  getStartupConf() {
+    var params = this.connectionParameters
 
-Client.prototype.cancel = function (client, query) {
-  if (client.activeQuery === query) {
-    var con = this.connection
+    var data = {
+      user: params.user,
+      database: params.database,
+    }
 
-    if (this.host && this.host.indexOf('/') === 0) {
-      con.connect(this.host + '/.s.PGSQL.' + this.port)
-    } else {
-      con.connect(this.port, this.host)
+    var appName = params.application_name || params.fallback_application_name
+    if (appName) {
+      data.application_name = appName
+    }
+    if (params.replication) {
+      data.replication = '' + params.replication
+    }
+    if (params.statement_timeout) {
+      data.statement_timeout = String(parseInt(params.statement_timeout, 10))
+    }
+    if (params.idle_in_transaction_session_timeout) {
+      data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10))
+    }
+    if (params.options) {
+      data.options = params.options
     }
 
-    // once connection is established send cancel message
-    con.on('connect', function () {
-      con.cancel(client.processID, client.secretKey)
-    })
-  } else if (client.queryQueue.indexOf(query) !== -1) {
-    client.queryQueue.splice(client.queryQueue.indexOf(query), 1)
+    return data
   }
-}
 
-Client.prototype.setTypeParser = function (oid, format, parseFn) {
-  return this._types.setTypeParser(oid, format, parseFn)
-}
-
-Client.prototype.getTypeParser = function (oid, format) {
-  return this._types.getTypeParser(oid, format)
-}
+  cancel(client, query) {
+    if (client.activeQuery === query) {
+      var con = this.connection
 
-// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
-Client.prototype.escapeIdentifier = function (str) {
-  return '"' + str.replace(/"/g, '""') + '"'
-}
+      if (this.host && this.host.indexOf('/') === 0) {
+        con.connect(this.host + '/.s.PGSQL.' + this.port)
+      } else {
+        con.connect(this.port, this.host)
+      }
 
-// Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
-Client.prototype.escapeLiteral = function (str) {
-  var hasBackslash = false
-  var escaped = "'"
-
-  for (var i = 0; i < str.length; i++) {
-    var c = str[i]
-    if (c === "'") {
-      escaped += c + c
-    } else if (c === '\\') {
-      escaped += c + c
-      hasBackslash = true
-    } else {
-      escaped += c
+      // once connection is established send cancel message
+      con.on('connect', function () {
+        con.cancel(client.processID, client.secretKey)
+      })
+    } else if (client.queryQueue.indexOf(query) !== -1) {
+      client.queryQueue.splice(client.queryQueue.indexOf(query), 1)
     }
   }
 
-  escaped += "'"
-
-  if (hasBackslash === true) {
-    escaped = ' E' + escaped
+  setTypeParser(oid, format, parseFn) {
+    return this._types.setTypeParser(oid, format, parseFn)
   }
 
-  return escaped
-}
+  getTypeParser(oid, format) {
+    return this._types.getTypeParser(oid, format)
+  }
 
-Client.prototype._pulseQueryQueue = function () {
-  if (this.readyForQuery === true) {
-    this.activeQuery = this.queryQueue.shift()
-    if (this.activeQuery) {
-      this.readyForQuery = false
-      this.hasExecuted = true
+  // Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+  escapeIdentifier(str) {
+    return '"' + str.replace(/"/g, '""') + '"'
+  }
 
-      const queryError = this.activeQuery.submit(this.connection)
-      if (queryError) {
-        process.nextTick(() => {
-          this.activeQuery.handleError(queryError, this.connection)
-          this.readyForQuery = true
-          this._pulseQueryQueue()
-        })
+  // Ported from PostgreSQL 9.2.4 source code in src/interfaces/libpq/fe-exec.c
+  escapeLiteral(str) {
+    var hasBackslash = false
+    var escaped = "'"
+
+    for (var i = 0; i < str.length; i++) {
+      var c = str[i]
+      if (c === "'") {
+        escaped += c + c
+      } else if (c === '\\') {
+        escaped += c + c
+        hasBackslash = true
+      } else {
+        escaped += c
       }
-    } else if (this.hasExecuted) {
-      this.activeQuery = null
-      this.emit('drain')
     }
+
+    escaped += "'"
+
+    if (hasBackslash === true) {
+      escaped = ' E' + escaped
+    }
+
+    return escaped
   }
-}
 
-Client.prototype.query = function (config, values, callback) {
-  // can take in strings, config object or query object
-  var query
-  var result
-  var readTimeout
-  var readTimeoutTimer
-  var queryCallback
-
-  if (config === null || config === undefined) {
-    throw new TypeError('Client was passed a null or undefined query')
-  } else if (typeof config.submit === 'function') {
-    readTimeout = config.query_timeout || this.connectionParameters.query_timeout
-    result = query = config
-    if (typeof values === 'function') {
-      query.callback = query.callback || values
-    }
-  } else {
-    readTimeout = this.connectionParameters.query_timeout
-    query = new Query(config, values, callback)
-    if (!query.callback) {
-      result = new this._Promise((resolve, reject) => {
-        query.callback = (err, res) => (err ? reject(err) : resolve(res))
-      })
+  _pulseQueryQueue() {
+    if (this.readyForQuery === true) {
+      this.activeQuery = this.queryQueue.shift()
+      if (this.activeQuery) {
+        this.readyForQuery = false
+        this.hasExecuted = true
+
+        const queryError = this.activeQuery.submit(this.connection)
+        if (queryError) {
+          process.nextTick(() => {
+            this.activeQuery.handleError(queryError, this.connection)
+            this.readyForQuery = true
+            this._pulseQueryQueue()
+          })
+        }
+      } else if (this.hasExecuted) {
+        this.activeQuery = null
+        this.emit('drain')
+      }
     }
   }
 
-  if (readTimeout) {
-    queryCallback = query.callback
+  query(config, values, callback) {
+    // can take in strings, config object or query object
+    var query
+    var result
+    var readTimeout
+    var readTimeoutTimer
+    var queryCallback
+
+    if (config === null || config === undefined) {
+      throw new TypeError('Client was passed a null or undefined query')
+    } else if (typeof config.submit === 'function') {
+      readTimeout = config.query_timeout || this.connectionParameters.query_timeout
+      result = query = config
+      if (typeof values === 'function') {
+        query.callback = query.callback || values
+      }
+    } else {
+      readTimeout = this.connectionParameters.query_timeout
+      query = new Query(config, values, callback)
+      if (!query.callback) {
+        result = new this._Promise((resolve, reject) => {
+          query.callback = (err, res) => (err ? reject(err) : resolve(res))
+        })
+      }
+    }
 
-    readTimeoutTimer = setTimeout(() => {
-      var error = new Error('Query read timeout')
+    if (readTimeout) {
+      queryCallback = query.callback
 
-      process.nextTick(() => {
-        query.handleError(error, this.connection)
-      })
+      readTimeoutTimer = setTimeout(() => {
+        var error = new Error('Query read timeout')
+
+        process.nextTick(() => {
+          query.handleError(error, this.connection)
+        })
+
+        queryCallback(error)
+
+        // we already returned an error,
+        // just do nothing if query completes
+        query.callback = () => {}
 
-      queryCallback(error)
+        // Remove from queue
+        var index = this.queryQueue.indexOf(query)
+        if (index > -1) {
+          this.queryQueue.splice(index, 1)
+        }
 
-      // we already returned an error,
-      // just do nothing if query completes
-      query.callback = () => {}
+        this._pulseQueryQueue()
+      }, readTimeout)
 
-      // Remove from queue
-      var index = this.queryQueue.indexOf(query)
-      if (index > -1) {
-        this.queryQueue.splice(index, 1)
+      query.callback = (err, res) => {
+        clearTimeout(readTimeoutTimer)
+        queryCallback(err, res)
       }
+    }
 
-      this._pulseQueryQueue()
-    }, readTimeout)
+    if (this.binary && !query.binary) {
+      query.binary = true
+    }
 
-    query.callback = (err, res) => {
-      clearTimeout(readTimeoutTimer)
-      queryCallback(err, res)
+    if (query._result && !query._result._types) {
+      query._result._types = this._types
     }
-  }
 
-  if (this.binary && !query.binary) {
-    query.binary = true
-  }
+    if (!this._queryable) {
+      process.nextTick(() => {
+        query.handleError(new Error('Client has encountered a connection error and is not queryable'), this.connection)
+      })
+      return result
+    }
 
-  if (query._result && !query._result._types) {
-    query._result._types = this._types
-  }
+    if (this._ending) {
+      process.nextTick(() => {
+        query.handleError(new Error('Client was closed and is not queryable'), this.connection)
+      })
+      return result
+    }
 
-  if (!this._queryable) {
-    process.nextTick(() => {
-      query.handleError(new Error('Client has encountered a connection error and is not queryable'), this.connection)
-    })
+    this.queryQueue.push(query)
+    this._pulseQueryQueue()
     return result
   }
 
-  if (this._ending) {
-    process.nextTick(() => {
-      query.handleError(new Error('Client was closed and is not queryable'), this.connection)
-    })
-    return result
-  }
+  end(cb) {
+    this._ending = true
 
-  this.queryQueue.push(query)
-  this._pulseQueryQueue()
-  return result
-}
+    // if we have never connected, then end is a noop, callback immediately
+    if (!this.connection._connecting) {
+      if (cb) {
+        cb()
+      } else {
+        return this._Promise.resolve()
+      }
+    }
 
-Client.prototype.end = function (cb) {
-  this._ending = true
+    if (this.activeQuery || !this._queryable) {
+      // if we have an active query we need to force a disconnect
+      // on the socket - otherwise a hung query could block end forever
+      this.connection.stream.destroy()
+    } else {
+      this.connection.end()
+    }
 
-  // if we have never connected, then end is a noop, callback immediately
-  if (!this.connection._connecting) {
     if (cb) {
-      cb()
+      this.connection.once('end', cb)
     } else {
-      return this._Promise.resolve()
+      return new this._Promise((resolve) => {
+        this.connection.once('end', resolve)
+      })
     }
   }
-
-  if (this.activeQuery || !this._queryable) {
-    // if we have an active query we need to force a disconnect
-    // on the socket - otherwise a hung query could block end forever
-    this.connection.stream.destroy()
-  } else {
-    this.connection.end()
-  }
-
-  if (cb) {
-    this.connection.once('end', cb)
-  } else {
-    return new this._Promise((resolve) => {
-      this.connection.once('end', resolve)
-    })
-  }
 }
 
 // expose a Query constructor