Merge pull request #637 from reedog117/mariadb

mariadb major updates

Merge pull request #637 from reedog117/mariadb
mariadb major updates
Jan Aagaard Meier
Commit 655a603d authored Sep 27, 2013 by Jan Aagaard Meier
Showing with 278 additions and 122 deletions
.travis.yml
lib/dialects/mariadb/connector-manager.js
lib/dialects/mariadb/query-generator.js
lib/dialects/mariadb/query.js
package.json
spec-jasmine/config/config.js
spec-jasmine/dao-factory.spec.js
spec-jasmine/dao.spec.js
spec/config/config.js
spec/dao-factory.spec.js
spec/sequelize.spec.js
--- a/.travis.yml
+++ b/.travis.yml
@@ -15,8 +15,9 @@ env:
  - DB=mysql DIALECT=postgres
  - DB=mysql DIALECT=postgres-native
  - DB=mysql DIALECT=sqlite
+  - DB=mysql DIALECT=mariadb
 language: node_js
 node_js:
  - 0.8
\ No newline at end of file
--- a/lib/dialects/mariadb/connector-manager.js
+++ b/lib/dialects/mariadb/connector-manager.js
@@ -108,7 +108,7 @@ module.exports = (function() {
    } else if (this.poolCfg) {
      //the user has requested pooling, so create our connection pool
      this.pool = Pooling.Pool({
-        name: 'sequelize-mariasql',
+        name: 'sequelize-mariadb',
        create: function (done) {
          connect.call(self, done)
        },
@@ -207,38 +207,23 @@ module.exports = (function() {
  var disconnect = function(client) {
    var self = this;
-    if (!this.useQueue) {
-      this.client = null;
+    if(client.connected) {
+      client.end()
    }
-    client.end(function() {
+    self.client = null
-      if (!self.useQueue) {
+    self.isConnecting = false
-        return client.destroy();
-      }
-      var intervalObj = null
+    return
-      var cleanup = function () {
-        var retryCt = 0
-        // make sure to let client finish before calling destroy
-        if (self && self.hasQueuedItems) {
-          return
-        }
-        // needed to prevent mariasql connection leak
-        client.destroy()
-        if (self && self.client) {
-          self.client = null
-        }
-        clearInterval(intervalObj)
-      }
-      intervalObj = setInterval(cleanup, 10)
-      cleanup()
-      return
-    })
  }
  var connect = function(done, config) {
    config = config || this.config
-    var connection = new mariasql();
+    var connection = new mariasql()
+      , self = this
    this.isConnecting = true
    connection.connect({
      host: config.host,
@@ -252,10 +237,14 @@ module.exports = (function() {
    connection.on('connect', function() {
      connection.query("SET time_zone = '+0:00'");
-      // client.setMaxListeners(self.maxConcurrentQueries)
+      connection.setMaxListeners(self.maxConcurrentQueries)
      this.isConnecting = false
      done(null, connection)      
+    }).on('error', function() {
+      disconnect.call(self, connection)
+    }).on('close', function() {
+      disconnect.call(self, connection)
    })
  }
@@ -295,6 +284,10 @@ module.exports = (function() {
  }
  var transferQueuedItems = function(count) {
+    // prevent possible overrun condition
+    if( count > this.queue.length )
+      count = this.queue.length
    for(var i = 0; i < count; i++) {
      var queueItem = this.queue.shift();
      if (queueItem) {
@@ -332,7 +325,7 @@ module.exports = (function() {
  })
  ConnectorManager.prototype.__defineGetter__('isConnected', function() {
-    return this.client != null
+    return this.client != null && this.client.connected == true
  })
  var disconnectIfNoConnections = function() {

--- a/lib/dialects/mariadb/query-generator.js
+++ b/lib/dialects/mariadb/query-generator.js
@@ -45,6 +45,7 @@ module.exports = (function() {
      var query   = "CREATE TABLE IF NOT EXISTS <%= table %> (<%= attributes%>) ENGINE=<%= engine %> <%= charset %>"
        , primaryKeys = []
+        , foreignKeys = {}
        , attrStr = []
      for (var attr in attributes) {
@@ -54,6 +55,11 @@ module.exports = (function() {
          if (Utils._.includes(dataType, 'PRIMARY KEY')) {
            primaryKeys.push(attr)
            attrStr.push(QueryGenerator.addQuotes(attr) + " " + dataType.replace(/PRIMARY KEY/, ''))
+          } else if (Utils._.includes(dataType, 'REFERENCES')) {
+            // MySQL doesn't support inline REFERENCES declarations: move to the end
+            var m = dataType.match(/^(.+) (REFERENCES.*)$/)
+            attrStr.push(QueryGenerator.addQuotes(attr) + " " + m[1])
+            foreignKeys[attr] = m[2]
          } else {
            attrStr.push(QueryGenerator.addQuotes(attr) + " " + dataType)
          }
@@ -72,6 +78,12 @@ module.exports = (function() {
        values.attributes += ", PRIMARY KEY (" + pkString + ")"
      }
+      for (var fkey in foreignKeys) {
+        if(foreignKeys.hasOwnProperty(fkey)) {
+          values.attributes += ", FOREIGN KEY (" + QueryGenerator.addQuotes(fkey) + ") " + foreignKeys[fkey]
+        }
+      }
      return Utils._.template(query)(values).trim() + ";"
    },
@@ -149,8 +161,8 @@ module.exports = (function() {
    },
    selectQuery: function(tableName, options) {
-      var query = "SELECT <%= attributes %> FROM <%= table %>"
+      var table = null,
-        , table = null
+          joinQuery = ""
      options            = options || {}
      options.table      = table = Array.isArray(tableName) ? tableName.map(function(tbl){ return QueryGenerator.addQuotes(tbl) }).join(", ") : QueryGenerator.addQuotes(tableName)
@@ -168,75 +180,92 @@ module.exports = (function() {
        options.include.forEach(function(include) {
          var attributes = Object.keys(include.daoFactory.attributes).map(function(attr) {
-            var template = Utils._.template("`<%= as %>`.`<%= attr %>` AS `<%= as %>.<%= attr %>`")
+            return "`" + include.as + "`.`" + attr + "` AS `" + include.as + "." + attr + "`"
-            return template({ as: include.as, attr: attr })
          })
          optAttributes = optAttributes.concat(attributes)
-          var joinQuery = " LEFT OUTER JOIN `<%= table %>` AS `<%= as %>` ON `<%= tableLeft %>`.`<%= attrLeft %>` = `<%= tableRight %>`.`<%= attrRight %>`"
+          var table = include.daoFactory.tableName
-          query += Utils._.template(joinQuery)({
+          var as = include.as
-            table:      include.daoFactory.tableName,
+          var tableLeft = ((include.association.associationType === 'BelongsTo') ? include.as : tableName)
-            as:         include.as,
+          var attrLeft = 'id'
-            tableLeft:  ((include.association.associationType === 'BelongsTo') ? include.as : tableName),
+          var tableRight = ((include.association.associationType === 'BelongsTo') ? tableName : include.as)
-            attrLeft:   'id',
+          var attrRight = include.association.identifier
-            tableRight: ((include.association.associationType === 'BelongsTo') ? tableName : include.as),
+          joinQuery += " LEFT OUTER JOIN `" + table + "` AS `" + as + "` ON `" + tableLeft + "`.`" + attrLeft + "` = `" + tableRight + "`.`" + attrRight + "`"
-            attrRight:  include.association.identifier
-          })
        })
        options.attributes = optAttributes.join(', ')
      }
-      if (options.where) {
+      var query = "SELECT " + options.attributes + " FROM " + options.table
+      query += joinQuery
+      if (options.hasOwnProperty('where')) {
        options.where = this.getWhereConditions(options.where, tableName)
-        query += " WHERE <%= where %>"
+        query += " WHERE " + options.where
      }
      if (options.group) {
        options.group = Array.isArray(options.group) ? options.group.map(function(grp){return QueryGenerator.addQuotes(grp)}).join(', ') : QueryGenerator.addQuotes(options.group)
-        query += " GROUP BY <%= group %>"
+        query += " GROUP BY " + options.group
      }
      if (options.order) {
-        query += " ORDER BY <%= order %>"
+        query += " ORDER BY " + options.order
      }
      if (options.limit && !(options.include && (options.limit === 1))) {
        if (options.offset) {
-          query += " LIMIT <%= offset %>, <%= limit %>"
+          query += " LIMIT " + options.offset + ", " + options.limit
        } else {
-          query += " LIMIT <%= limit %>"
+          query += " LIMIT " + options.limit
        }
      }
      query += ";"
-      return Utils._.template(query)(options)
+      return query
    },
    insertQuery: function(tableName, attrValueHash) {
      attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
-      var query = "INSERT INTO <%= table %> (<%= attributes %>) VALUES (<%= values %>);"
+      var table = QueryGenerator.addQuotes(tableName)
+      var attributes = Object.keys(attrValueHash).map(function(attr){return QueryGenerator.addQuotes(attr)}).join(",")
-      var replacements  = {
+      var values = Utils._.values(attrValueHash).map(function(value){
-        table: QueryGenerator.addQuotes(tableName),
-        attributes: Object.keys(attrValueHash).map(function(attr){return QueryGenerator.addQuotes(attr)}).join(","),
-        values: Utils._.values(attrValueHash).map(function(value){
          return Utils.escape((value instanceof Date) ? Utils.toSqlDate(value) : value)
        }).join(",")
-      }
-      return Utils._.template(query)(replacements)
+      var query = "INSERT INTO " + table + " (" + attributes + ") VALUES (" + values + ");"
+      return query
+    },
+    bulkInsertQuery: function(tableName, attrValueHashes) {
+      var tuples = []
+      Utils._.forEach(attrValueHashes, function(attrValueHash) {
+        tuples.push("(" +
+          Utils._.values(attrValueHash).map(function(value){
+            return Utils.escape((value instanceof Date) ? Utils.toSqlDate(value) : value)
+          }).join(",") +
+        ")")
+      })
+      var table      = QueryGenerator.addQuotes(tableName)
+      var attributes = Object.keys(attrValueHashes[0]).map(function(attr){return QueryGenerator.addQuotes(attr)}).join(",")
+      var query  = "INSERT INTO " + table + " (" + attributes + ") VALUES " + tuples.join(",") + ";"
+      return query
    },
    updateQuery: function(tableName, attrValueHash, where) {
      attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
-      var query  = "UPDATE <%= table %> SET <%= values %> WHERE <%= where %>;"
+      var values = []
-        , values = []
      for (var key in attrValueHash) {
        var value  = attrValueHash[key]
@@ -245,34 +274,48 @@ module.exports = (function() {
        values.push(QueryGenerator.addQuotes(key) + "=" + Utils.escape(_value))
      }
-      var replacements = {
+      var query = "UPDATE " + QueryGenerator.addQuotes(tableName) +
-        table: QueryGenerator.addQuotes(tableName),
+                  " SET " + values.join(",") +
-        values: values.join(","),
+                  " WHERE " + QueryGenerator.getWhereConditions(where)
-        where: QueryGenerator.getWhereConditions(where)
-      }
-      return Utils._.template(query)(replacements)
+      return query
    },
    deleteQuery: function(tableName, where, options) {
      options = options || {}
-      options.limit = options.limit || 1
-      var query = "DELETE FROM <%= table %> WHERE <%= where %> LIMIT <%= limit %>;"
+      var table = QueryGenerator.addQuotes(tableName)
-      var replacements = {
+      var where = QueryGenerator.getWhereConditions(where)
-        table: QueryGenerator.addQuotes(tableName),
+      var limit = ""
-        where: QueryGenerator.getWhereConditions(where),
-        limit: Utils.escape(options.limit)
+      if(Utils._.isUndefined(options.limit)) {
+        options.limit = 1;
+      }
+      if(!!options.limit) {
+        limit = " LIMIT " + Utils.escape(options.limit)
      }
-      return Utils._.template(query)(replacements)
+      var query = "DELETE FROM " + table + " WHERE " + where + limit
+      return query
+    },
+    bulkDeleteQuery: function(tableName, where, options) {
+      options = options || {}
+      var table = QueryGenerator.addQuotes(tableName)
+      var where = QueryGenerator.getWhereConditions(where)
+      var query = "DELETE FROM " + table + " WHERE " + where
+      return query
    },
    incrementQuery: function (tableName, attrValueHash, where) {
      attrValueHash = Utils.removeNullValuesFromHash(attrValueHash, this.options.omitNull)
-      var query = "UPDATE <%= table %> SET <%= values %> WHERE <%= where %> ;"
+      var values = []
-        , values = []
      for (var key in attrValueHash) {
        var value  = attrValueHash[key]
@@ -281,13 +324,13 @@ module.exports = (function() {
        values.push(QueryGenerator.addQuotes(key) + "=" + QueryGenerator.addQuotes(key) + " + " +Utils.escape(_value))
      }
-      var replacements = {
+      var table = QueryGenerator.addQuotes(tableName)
-        table: QueryGenerator.addQuotes(tableName),
+      var values =  values.join(",")
-        values: values.join(","),
+      var where = QueryGenerator.getWhereConditions(where)
-        where: QueryGenerator.getWhereConditions(where)
-      }
+      var query = "UPDATE " + table + " SET " + values + " WHERE " + where
-      return Utils._.template(query)(replacements)
+      return query
    },
    addIndexQuery: function(tableName, attributes, options) {
@@ -355,23 +398,14 @@ module.exports = (function() {
    getWhereConditions: function(smth, tableName) {
      var result = null
-      function isNumeric(n) {
-        return !isNaN(parseFloat(n)) && isFinite(n);
-      }
      if (Utils.isHash(smth)) {
        smth   = Utils.prependTableNameToHash(tableName, smth)
        result = this.hashToWhereConditions(smth)
      } else if (typeof smth === 'number') {
-        smth   = Utils.prependTableNameToHash(tableName, { 'id': smth })
+        smth   = Utils.prependTableNameToHash(tableName, { id: smth })
        result = this.hashToWhereConditions(smth)
      } else if (typeof smth === "string") {
-        if (!isNumeric(smth)) {
+        result = smth
-          result = smth
-        } else {
-          smth   = Utils.prependTableNameToHash(tableName, { 'id': smth })
-          result = this.hashToWhereConditions(smth)
-        }
      } else if (Array.isArray(smth)) {
        result = Utils.format(smth)
      }
@@ -419,17 +453,18 @@ module.exports = (function() {
        var dataType = attributes[name]
        if (Utils.isHash(dataType)) {
-          var template     = "<%= type %>"
+          var template
-            , replacements = { type: dataType.type }
          if (dataType.type.toString() === DataTypes.ENUM.toString()) {
            if (Array.isArray(dataType.values) && (dataType.values.length > 0)) {
-              replacements.type = "ENUM(" + Utils._.map(dataType.values, function(value) {
+              template = "ENUM(" + Utils._.map(dataType.values, function(value) {
                return Utils.escape(value)
              }).join(", ") + ")"
            } else {
              throw new Error('Values for ENUM haven\'t been defined.')
            }
+          } else {
+            template = dataType.type.toString();
          }
          if (dataType.hasOwnProperty('allowNull') && (!dataType.allowNull)) {
@@ -441,8 +476,7 @@ module.exports = (function() {
          }
          if ((dataType.defaultValue != undefined) && (dataType.defaultValue != DataTypes.NOW)) {
-            template += " DEFAULT <%= defaultValue %>"
+            template += " DEFAULT " + Utils.escape(dataType.defaultValue)
-            replacements.defaultValue = Utils.escape(dataType.defaultValue)
          }
          if (dataType.unique) {
@@ -453,7 +487,27 @@ module.exports = (function() {
            template += " PRIMARY KEY"
          }
-          result[name] = Utils._.template(template)(replacements)
+          if(dataType.references) {
+            template += " REFERENCES " + Utils.addTicks(dataType.references)
+            if(dataType.referencesKey) {
+              template += " (" + Utils.addTicks(dataType.referencesKey) + ")"
+            } else {
+              template += " (" + Utils.addTicks('id') + ")"
+            }
+            if(dataType.onDelete) {
+              template += " ON DELETE " + dataType.onDelete.toUpperCase()
+            }
+            if(dataType.onUpdate) {
+              template += " ON UPDATE " + dataType.onUpdate.toUpperCase()
+            }
+          }
+          result[name] = template
        } else {
          result[name] = dataType
        }

--- a/lib/dialects/mariadb/query.js
+++ b/lib/dialects/mariadb/query.js
@@ -23,34 +23,131 @@ module.exports = (function() {
      this.options.logging('Executing: ' + this.sql)
    }
-    var resultSet = [];
+    var resultSet = [],
+        errorDetected = false,
+        self = this
    this.client.query(this.sql)
      .on('result', function(results) {
-        results.on('row', function(row) {
+      results.on('row', function(row) {
-            resultSet.push(row);
+          // iterate through each property to convert
-          })
+          // strings into JS objects when possible
-          .on('error', function(err) {
+          for(var prop in row) {
-            this.emit('error', err, this.callee)
+            // take care of properties that shouldn't be strings
-          })  
+            if( row[prop] == null) {
-          .on('end', function(info) {
+              continue; // don't mess with null
-            //console.log(info)
+            } else if( parseIso8601.call(this, row[prop]) ) {
-          });
+              // if string can be converted into a JS date, it probably
+              // is a JS date -- replace the string with the date
+              row[prop] = parseIso8601.call(this, row[prop] + 'Z')
+            } else if( !isNaN(row[prop]) ) {
+              // take care of strings that are really numbers
+              row[prop] = +(row[prop]);
+            } 
+          }
+          resultSet.push(row)
        })
+        .on('error', function(err) {
+          errorDetected = true
+          self.emit('sql', this.sql)
+          self.emit('error', err, this.callee)
+        }.bind(this))  
+        .on('end', function(info) {
+          if(errorDetected) {
+            return
+          }
+          self.emit('sql', this.sql)
+          // we need to figure out whether to send the result set
+          // or info depending upon the type of query
+          if( /^show/.test(this.sql.toLowerCase()) ||
+            /^select/.test(this.sql.toLowerCase()) ||
+            /^describe/.test(this.sql.toLowerCase()) ||
+            ( resultSet.length && /^call/.test(this.sql.toLowerCase()) ) ) {
+            self.emit('success', this.formatResults(resultSet))         
+          } else {
+            self.emit('success', this.formatResults(info))
+          }
+        }.bind(this));
+      }.bind(this))
      .on('error', function(err) {
-        console.log( stack )
+        if(errorDetected) {
-        //this.emit('error', err, this.callee)
+          return
-      })  
+        }
-      .on('end', function() {
+        errorDetected = true
-        this.emit('sql', this.sql)
+        self.emit('sql', this.sql)
-        this.emit('success', this.formatResults(resultSet))
+        self.emit('error', err, this.callee)
      }.bind(this))
+      .on('end', function(info) {
+        // nothing here (query info is returned during the 'result' event)
+      }.bind(this)).setMaxListeners(100)
    return this
  }
+  var parseIso8601 = function(CurDate) {
+    // note -- this function is borrowed from the following author
+    // Author: Jim Davis, The Depressed Press of Boston
+    // Library: DP_DateExtensions
+    // Website: www.depressedpress.com
+    // Check the input parameters
+  if ( typeof CurDate != "string" || CurDate == "" ) {
+    return null;
+  };
+    // Set the fragment expressions
+  var S = "[\\-/:.]";
+  var Yr = "((?:1[6-9]|[2-9][0-9])[0-9]{2})";
+  var Mo = S + "((?:1[012])|(?:0[1-9])|[1-9])";
+  var Dy = S + "((?:3[01])|(?:[12][0-9])|(?:0[1-9])|[1-9])";
+  var Hr = "(2[0-4]|[01]?[0-9])";
+  var Mn = S + "([0-5]?[0-9])";
+  var Sd = "(?:" + S + "([0-5]?[0-9])(?:[.,]([0-9]+))?)?";
+  var TZ = "(?:(Z)|(?:([\+\-])(1[012]|[0]?[0-9])(?::?([0-5]?[0-9]))?))?";
+    // RegEx the input
+    // First check: Just date parts (month and day are optional)
+    // Second check: Full date plus time (seconds, milliseconds and TimeZone info are optional)
+  var TF;
+  if ( TF = new RegExp("^" + Yr + "(?:" + Mo + "(?:" + Dy + ")?)?" + "$").exec(CurDate) ) {} else if ( TF = new RegExp("^" + Yr + Mo + Dy + "[Tt ]" + Hr + Mn + Sd + TZ + "$").exec(CurDate) ) {};
+    // If the date couldn't be parsed, return null
+  if ( !TF ) { return null };
+    // Default the Time Fragments if they're not present
+  if ( !TF[2] ) { TF[2] = 1 } else { TF[2] = TF[2] - 1 };
+  if ( !TF[3] ) { TF[3] = 1 };
+  if ( !TF[4] ) { TF[4] = 0 };
+  if ( !TF[5] ) { TF[5] = 0 };
+  if ( !TF[6] ) { TF[6] = 0 };
+  if ( !TF[7] ) { TF[7] = 0 };
+  if ( !TF[8] ) { TF[8] = null };
+  if ( TF[9] != "-" && TF[9] != "+" ) { TF[9] = null };
+  if ( !TF[10] ) { TF[10] = 0 } else { TF[10] = TF[9] + TF[10] };
+  if ( !TF[11] ) { TF[11] = 0 } else { TF[11] = TF[9] + TF[11] };
+    // If there's no timezone info the data is local time
+  if ( !TF[8] && !TF[9] ) {
+    return new Date(TF[1], TF[2], TF[3], TF[4], TF[5], TF[6], TF[7]);
+  };
+    // If the UTC indicator is set the date is UTC
+  if ( TF[8] == "Z" ) {
+    return new Date(Date.UTC(TF[1], TF[2], TF[3], TF[4], TF[5], TF[6], TF[7]));
+  };
+    // If the date has a timezone offset
+  if ( TF[9] == "-" || TF[9] == "+" ) {
+      // Get current Timezone information
+    var CurTZ = new Date().getTimezoneOffset();
+    var CurTZh = TF[10] - ((CurTZ >= 0 ? "-" : "+") + Math.floor(Math.abs(CurTZ) / 60))
+    var CurTZm = TF[11] - ((CurTZ >= 0 ? "-" : "+") + (Math.abs(CurTZ) % 60))
+      // Return the date
+    return new Date(TF[1], TF[2], TF[3], TF[4] - CurTZh, TF[5] - CurTZm, TF[6], TF[7]);
+  };
+    // If we've reached here we couldn't deal with the input, return null
+  return null;
+};
  return Query
 })()

--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
    "validator": "1.1.1",
    "moment": "~1.7.0",
    "commander": "~0.6.0",
-    "generic-pool": "1.0.9",
+    "generic-pool": "1.0.12",
    "dottie": "0.0.6-1",
    "toposort-class": "0.1.4"
  },
@@ -47,8 +47,7 @@
    "mariasql": "~0.1.18",
    "buster": "~0.6.0",
    "watchr": "~2.2.0",
-    "yuidocjs": "~0.3.36",
+    "yuidocjs": "~0.3.36"
-    "mariasql": "~0.1.18"
  },
  "keywords": [
    "mysql",

--- a/spec-jasmine/config/config.js
+++ b/spec-jasmine/config/config.js
@@ -13,6 +13,15 @@ module.exports = {
    pool: { maxConnections: 5, maxIdleTime: 30}
  },
+  mariadb: {
+    username: "root",
+    password: null,
+    database: 'sequelize_test',
+    host: '127.0.0.1',
+    port: 3306,
+    pool: { maxConnections: 5, maxIdleTime: 30}
+  },
  sqlite: {
  },

--- a/spec-jasmine/dao-factory.spec.js
+++ b/spec-jasmine/dao-factory.spec.js
 var config    = require("./config/config")
  , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql', 'postgres']
+  , dialects  = ['sqlite', 'mysql', 'mariadb', 'postgres']
 describe('DAOFactory', function() {
  dialects.forEach(function(dialect) {

--- a/spec-jasmine/dao.spec.js
+++ b/spec-jasmine/dao.spec.js
 var config    = require("./config/config")
  , Sequelize = require("../index")
-  , dialects  = ['sqlite', 'mysql', 'postgres']
+  , dialects  = ['sqlite', 'mysql', 'mariadb', 'postgres']
 describe('DAO', function() {
  dialects.forEach(function(dialect) {

--- a/spec/config/config.js
+++ b/spec/config/config.js
@@ -25,7 +25,8 @@ module.exports = {
    database: 'sequelize_test',
    host: '127.0.0.1',
    port: 3306,
-    pool: { maxConnections: 5, maxIdleTime: 30}
+    pool: { maxConnections: 5, maxIdleTime: 30},
+    logging: console.log
  },
  sqlite: {

--- a/spec/dao-factory.spec.js
+++ b/spec/dao-factory.spec.js
@@ -168,6 +168,7 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
            Helpers.checkMatchForDialects(dialect, err.message, {
              sqlite: /.*SQLITE_CONSTRAINT.*/,
              mysql: /.*Duplicate\ entry.*/,
+              mariadb: /.*Duplicate\ entry.*/,
              postgres: /.*duplicate\ key\ value.*/
            })
@@ -190,6 +191,7 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
          Helpers.checkMatchForDialects(dialect, err.message, {
            sqlite: /.*SQLITE_CONSTRAINT.*/,
            mysql: "Column 'smth' cannot be null",
+            mariadb: "Column 'smth' cannot be null",
            postgres: /.*column "smth" violates not-null.*/
          })
@@ -200,6 +202,7 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
              Helpers.checkMatchForDialects(dialect, err.message, {
                sqlite: /.*SQLITE_CONSTRAINT.*/,
                mysql: "Duplicate entry 'foo' for key 'username'",
+                mariadb: "Duplicate entry 'foo' for key 'username'",
                postgres: /.*duplicate key value violates unique constraint.*/
              })
@@ -1499,7 +1502,7 @@ describe(Helpers.getTestDialectTeaser("DAOFactory"), function() {
      })
    })
-    if (dialect === "mysql") {
+    if (dialect === "mysql" || dialect === "mariadb" ) {
      it("should take schemaDelimiter into account if applicable", function(done){
        var UserSpecialUnderscore = this.sequelize.define('UserSpecialUnderscore', {age: Sequelize.INTEGER}, {schema: 'hello', schemaDelimiter: '_'})
        var UserSpecialDblUnderscore = this.sequelize.define('UserSpecialDblUnderscore', {age: Sequelize.INTEGER})

--- a/spec/sequelize.spec.js
+++ b/spec/sequelize.spec.js
@@ -7,7 +7,7 @@ if(typeof require === 'function') {
 var qq = function(str) {
  if (dialect == 'postgres' || dialect == 'sqlite') {
    return '"' + str + '"'
-  } else if (dialect == 'mysql') {
+  } else if (dialect == 'mysql' || dialect == 'mariadb') {
    return '`' + str + '`'
  } else {
    return str