Start to add discoverSchema and name mapping

lib/adl.js

@@ -131,11 +131,28 @@ Schema.prototype.define = function defineClass(className, properties, settings)
         settings: settings
     };
 
+    var idInjection = settings.idInjection;
+    for(var p in properties) {
+        if(properties[p].id) {
+            idInjection = false;
+            ModelClass.prototype.__defineGetter__('id', function () {
+                return this.__data[p];
+            });
+            break;
+        }
+    }
+    // Add the id property
+    if (idInjection !== false) {
         ModelClass.prototype.__defineGetter__('id', function () {
             return this.__data.id;
         });
 
-    properties.id = properties.id || { type: Number };
+        // Set up the id property
+        properties.id = properties.id || { type: Number, id: true };
+        if (!properties.id.id) {
+            properties.id.id = true;
+        }
+    }
 
     ModelClass.forEachProperty = function (cb) {
         Object.keys(properties).forEach(cb);

lib/datasource.js

@@ -9,6 +9,7 @@ var EventEmitter = require('events').EventEmitter;
 var util = require('util');
 var path = require('path');
 var fs = require('fs');
+var async = require('async');
 
 var existsSync = fs.existsSync || path.existsSync;
 
@@ -373,12 +374,34 @@ function fromDBName(dbName, camelCase) {
  * @param cb
  */
 DataSource.prototype.discoverSchema = function (owner, table, cb) {
-    var dataSourceName = this.name;
+    var dataSourceName = this.name || this.adapter.name;
-    this.discoverModelProperties(owner, table, function (err, columns) {
+
+    async.parallel(
+        [
+            this.discoverModelProperties.bind(this, owner, table),
+            this.discoverPrimaryKeys.bind(this, owner, table),
+            this.discoverForeignKeys.bind(this, owner, table)
+        ], function (err, results) {
+
             if (err) {
                 cb && cb(err);
                 return;
             }
+
+            var columns = results[0];
+            var primaryKeys = results[1];
+            var pks = {}, fks = {};
+            primaryKeys.forEach(function(pk) {
+               pks[pk.columnName] = pk.keySeq;
+            });
+
+            console.log(pks);
+
+            var foreignKeys = results[2];
+            foreignKeys.forEach(function(fk) {
+               fks[fk.fkColumnName] = fk.keySeq;
+            });
+
             if (!columns) {
                 cb && cb();
                 return;
@@ -386,6 +409,7 @@ DataSource.prototype.discoverSchema = function(owner, table, cb) {
             var schema = {
                 name: fromDBName(table, false),
                 options: {
+                    idInjection: false // DO NOT add id property
                 },
                 properties: {
                 }
@@ -397,6 +421,8 @@ DataSource.prototype.discoverSchema = function(owner, table, cb) {
             };
             columns.forEach(function (item) {
                 var i = item;
+
+
                 var propName = fromDBName(item.columnName, true);
                 schema.properties[propName] =
                 {
@@ -404,6 +430,10 @@ DataSource.prototype.discoverSchema = function(owner, table, cb) {
                     required: (item.nullable === 'N'),
                     length: item.dataLength
                 };
+
+                if(pks[item.columnName]) {
+                    schema.properties[propName].id = pks[item.columnName];
+                }
                 schema.properties[propName][dataSourceName] = {
                     columnName: i.columnName,
                     dataType: i.dataType,
@@ -452,9 +482,72 @@ DataSource.prototype.freeze = function freeze() {
  * @param {String} modelName
  */
 DataSource.prototype.tableName = function (modelName) {
-    return this.definitions[modelName].settings.table = this.definitions[modelName].settings.table || modelName
+    var settings = this.definitions[modelName].settings;
+    if(settings[this.adapter.name]) {
+        return settings[this.adapter.name].table || modelName;
+    } else {
+        return modelName;
+    }
 };
 
+/**
+ * Return column name for specified modelName and propertyName
+ * @param modelName
+ * @param propertyName
+ * @returns {String} columnName
+ */
+DataSource.prototype.columnName = function (modelName, propertyName) {
+    var property = this.definitions[modelName].properties[propertyName];
+    if(property[this.adapter.name]) {
+        return property[this.adapter.name].columnName || propertyName;
+    } else {
+        return propertyName;
+    }
+};
+
+/**
+ * Return column names for specified modelName
+ * @param modelName
+ * @returns {[String]} column names
+ */
+DataSource.prototype.columnNames = function (modelName) {
+    var props = this.definitions[modelName].properties;
+    var cols = [];
+    for(var p in props) {
+        if(props[p][this.adapter.name]) {
+            cols.push(props[p][this.adapter.name].columnName || p);
+        } else {
+            cols.push(p);
+        }
+    }
+    return cols;
+};
+
+/**
+ * Find the ID column name
+ * @param modelName
+ * @returns {String} columnName for ID
+ */
+DataSource.prototype.getIDColumnName = function(modelName) {
+    var props = this.definitions[modelName].properties;
+    var self = this;
+    Object.keys(props).forEach(function(key) {
+        var columnInfo = props[key][self.adapter.name];
+        if(columnInfo && columnInfo.id) {
+            if(columnInfo.columnName) {
+                return columnInfo.columnName;
+            } else {
+                return key;
+            }
+        }
+    });
+    if(props.id) {
+        return 'id';
+    }
+    return null;
+}
+
+
 /**
  * Define foreign key
  * @param {String} className

lib/sql.js

@@ -25,6 +25,10 @@ BaseSQL.prototype.table = function (model) {
     return this._models[model].model.schema.tableName(model);
 };
 
+BaseSQL.prototype.column = function (model, property) {
+    return this._models[model].model.schema.columnName(model, property);
+};
+
 BaseSQL.prototype.escapeName = function (name) {
     throw new Error('escapeName method should be declared in adapter');
 };
@@ -33,6 +37,10 @@ BaseSQL.prototype.tableEscaped = function (model) {
     return this.escapeName(this.table(model));
 };
 
+BaseSQL.prototype.columnEscaped = function (model, property) {
+    return this.escapeName(this.column(model, property));
+};
+
 BaseSQL.prototype.define = function (descr) {
     if (!descr.settings) descr.settings = {};
     this._models[descr.model.modelName] = descr;

package.json

@@ -72,6 +72,7 @@
     "mocha": "~1.8.2"
   },
   "dependencies": {
+    "async": "latest",
     "inflection": "~1.2.5"
   }
 }