whatap 1.0.1 → 1.0.2

package/lib/util/anylist.js

@@ -0,0 +1,103 @@
+var INT = 1;
+var LONG = 2;
+var FLOAT = 3;
+var DOUBLE = 4;
+var STRING = 5;
+
+AnyList.INT = 1;
+AnyList.LONG = 2;
+AnyList.FLOAT = 3;
+AnyList.DOUBLE = 4;
+AnyList.STRING = 5;
+
+function AnyList(type, len){
+    this.type=type;
+    this.data = new Array(len);
+}
+AnyList.prototype.getType=function(){
+    return this.type;
+};
+AnyList.prototype.put=function(idx, d){
+    this.data[idx]=d;
+};
+
+AnyList.prototype.get=function(idx){
+    return this.data[idx];
+};
+AnyList.prototype.size = function () {
+    return this.data ? this.data.length : 0;
+};
+AnyList.prototype.write=function(o){
+     switch(this.type){
+        case INT: this.writeDecimal(o);  return  this;
+        case LONG: this.writeDecimal(o);  return  this; 
+        case FLOAT: this.writeFloat(o);  return  this;
+        case DOUBLE: this.writeDouble(o);  return  this;
+        case STRING: this.writeString(o); return  this;
+     }
+};
+AnyList.prototype.read=function(i){
+    switch(this.type){
+       case INT: this.readDecimal(i);  return  this;
+       case LONG: this.readDecimal(i);  return  this; 
+       case FLOAT: this.readFloat(i);  return  this;
+       case DOUBLE: this.readDouble(i);  return  this;
+       case STRING: this.readString(i); return  this;
+    }
+};
+
+AnyList.prototype.writeDouble = function (dout) {
+    var len =this.size();
+    dout.writeInt24BE(len);
+    for (var i = 0; i < len; i++) {
+        dout.writeDouble(this.get(i));
+    }
+};
+AnyList.prototype.readDouble=function(din) {
+    var count = din.readInt24BE();
+    for (var i = 0; i < count; i++) {
+        this.add(din.readDouble());
+    }
+};
+AnyList.prototype.writeFloat = function (dout) {
+    var len =this.size();
+    dout.writeInt24BE(len);
+    for (var i = 0; i < len; i++) {
+        dout.writeFloat(this.get(i));
+    }
+};
+AnyList.prototype.readFloat=function(din) {
+    var count = din.readInt24BE();
+    for (var i = 0; i < count; i++) {
+        this.add(din.readFloat());
+    }
+};
+
+AnyList.prototype.writeDecimal = function (dout) {
+    var len =this.size();
+    dout.writeInt24BE(len);
+    for (var i = 0; i < len; i++) {
+        dout.writeDecimal(this.get(i));
+    }
+};
+AnyList.prototype.readDecimal=function(din) {
+    var count = din.readInt24BE();
+    for (var i = 0; i < count; i++) {
+        this.add(din.readDecNumber());
+    }
+};
+AnyList.prototype.writeString = function (dout) {
+    var len =this.size();
+    dout.writeInt24BE(len);
+    for (var i = 0; i < len; i++) {
+        dout.writeText(this.get(i));
+    }
+};
+AnyList.prototype.readString=function(din) {
+    var count = din.readInt24BE();
+    for (var i = 0; i < count; i++) {
+        this.add(din.readText());
+    }
+};
+
+module.exports = AnyList;

package/lib/util/cardinality/hyperloglog.js

@@ -0,0 +1,106 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var RegisterSet = require('./registerset'),
+    MurmurHash  = require('./murmurhash'),
+    DataOutpuxX = require('../../io/data-outputx'),
+    Long        = require('long');
+
+
+function HyperLogLog() {
+    this.log2m = 10;
+    this.registerSet = new RegisterSet(1 << this.log2m);
+    var m = 1 << this.log2m;
+    this.alphaMM = getAlphaMM(this.log2m, m);
+}
+
+HyperLogLog.prototype.offerHashed = function (hashedValue) {
+    var j = hashedValue >>> (32 - this.log2m);
+    var r = numberOfLeadingZeros((hashedValue << this.log2m) | (1 << (this.log2m - 1)) + 1) + 1;
+    return this.registerSet.updateIfGreater(j, r);
+};
+HyperLogLog.prototype.offer = function (o) {
+    var val;
+    if(o instanceof Long) {
+        val = o;
+    } else if(typeof o === 'string') {
+        val = Long.fromString(o);
+    } else if(typeof o === 'number') {
+        val = Long.fromNumber(o);
+    }
+    var x = MurmurHash.hashLong(val);
+    return this.offerHashed(x);
+};
+HyperLogLog.prototype.cardinality = function () {
+    var registerSum = 0;
+    var count = this.registerSet.count;
+    var zeros = 0.0;
+    for(var j=0; j<this.registerSet.count; j++) {
+        var val = this.registerSet.get(j);
+        registerSum += 1.0 / (1 << val);
+        if(parseFloat(val) === 0.0) {
+            zeros++;
+        }
+    }
+    var estimate = this.alphaMM * (1 / registerSum);
+    if(estimate <= (5.0 / 2.0) * count) {
+        return Math.round(linearCounting(count, zeros));
+    } else {
+        return Math.round(estimate);
+    }
+};
+HyperLogLog.prototype.getBytes = function () {
+    var dout = new DataOutpuxX();
+    dout.writeInt(this.log2m);
+    dout.writeInt(this.registerSet.size);
+    var M = this.registerSet.readOnlyBits();
+    for(var i=0; i<M.length; i++) {
+        dout.writeInt(M[i]);
+    }
+    return dout.toByteArray();
+};
+
+var getAlphaMM = function (p, m) {
+    switch (p) {
+        case 4:
+            return 0.673 * m * m;
+        case 5:
+            return 0.697 * m * m;
+        case 6:
+            return 0.709 * m * m;
+        default:
+            return (0.7213 / (1 + 1.079 / m)) * m * m;
+    }
+};
+var linearCounting = function (m, V) {
+    return m * Math.log(m / V);
+};
+var numberOfLeadingZeros = function (i) {
+    if (i === 0)
+        return 32;
+    var n = 1;
+
+    if (i >>> 16 === 0) {
+        n += 16;
+        i <<= 16;
+    }
+    if (i >>> 24 === 0) {
+        n += 8;
+        i <<= 8;
+    }
+    if (i >>> 28 === 0) {
+        n += 4;
+        i <<= 4;
+    }
+    if (i >>> 30 === 0) {
+        n += 2;
+        i <<= 2;
+    }
+    n -= i >>> 31;
+    return n;
+}
+
+module.exports = HyperLogLog;

package/lib/util/cardinality/murmurhash.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Long = require('long');
+
+function hash(data) {
+    var m = 0x5bd1e995;
+    var r = 24;
+    var h = 0;
+    var k = data.mul(m);
+    k = k.getLowBits();
+    k ^= k >>> r;
+    h ^= Long.fromNumber(k).mul(m).getLowBits();
+    k =  Long.fromNumber(data.getHighBits()).mul(m).getLowBits();
+    k ^= k >>> r;
+    h = Long.fromNumber(h).mul(m).getLowBits();
+    h ^= Long.fromNumber(k).mul(m).getLowBits();
+    h ^= h >>> 13;
+    h = Long.fromNumber(h).mul(m).getLowBits();
+    h ^= h >>> 15;
+    return h;
+};
+
+var MurMurHash = {
+    hashLong : hash
+};
+
+module.exports = MurMurHash;

package/lib/util/cardinality/registerset.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+const LOG2_BITS_PER_WORD    = 6;
+const REGISTER_SIZE         = 5;
+
+var Long = require('long');
+
+function RegisterSet(count) {
+    this.count = count;
+    this.M = new Array(getSizeForCount(this.count));
+    this.size = this.M.length;
+}
+
+RegisterSet.prototype.set = function (position, value) {
+    var bucketPos = parseInt(position / LOG2_BITS_PER_WORD);
+    var shift = REGISTER_SIZE * (position - (bucketPos * LOG2_BITS_PER_WORD));
+    this.M[bucketPos] = (this.M[bucketPos] & ~(0x1f << shift) | (value << shift));
+};
+RegisterSet.prototype.get = function (position) {
+    var bucketPos = parseInt(position / LOG2_BITS_PER_WORD);
+    var shift = REGISTER_SIZE * (position - (bucketPos * LOG2_BITS_PER_WORD));
+    return (this.M[bucketPos] & (0x1f << shift)) >>> shift;
+};
+RegisterSet.prototype.updateIfGreater = function (position, value) {
+    var bucket = parseInt(position / LOG2_BITS_PER_WORD);
+    var shift = REGISTER_SIZE * (position - (bucket * LOG2_BITS_PER_WORD));
+    var mask = 0x1f << shift;
+
+    var curVal = Long.fromNumber(this.M[bucket]).and(mask);
+    var newVal = Long.fromNumber(value).shiftLeft(shift);
+
+    if(newVal.greaterThan(curVal)) {
+        var tmp = Long.fromNumber(this.M[bucket]).and(~mask).or(newVal);
+        this.M[bucket] = tmp.getLowBits();
+        return true;
+    } else {
+        return false;
+    }
+};
+RegisterSet.prototype.merge = function (that) {
+
+    for(var bucket = 0; bucket < this.M.length; bucket++) {
+        var word = 0;
+        for(var j=0; j<LOG2_BITS_PER_WORD; j++) {
+            var mask = 0x1f << (REGISTER_SIZE * j);
+            var thisVal = (this.M[bucket] & mask);
+            var thatVal = (that.M[bucket] & mask);
+            word |= (thisVal < thatVal) ? thatVal : thisVal;
+        }
+        this.M[bucket] = word;
+    }
+};
+RegisterSet.prototype.readOnlyBits = function () {
+    return this.M;
+};
+
+function getSizeForCount(count) {
+    var bits = getBits(count);
+    if(bits === 0) {
+        return 1;
+    } else if(bits % 32 === 0) {
+        return bits;
+    } else {
+        return bits + 1;
+    }
+}
+function getBits(count) {
+    return parseInt(count / LOG2_BITS_PER_WORD);
+}
+
+module.exports = RegisterSet;

package/lib/util/errordata.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Step = require('../step/step');
+
+function ErrorData(error, dbc, service, profile, isStackTrace) {
+    this.error = error || {};
+    this.dbc = dbc || 0;
+    this.service = service || 0;
+    this.profile = profile || new Step();
+    this.isStackTrace = isStackTrace || null;
+}
+
+ErrorData.prototype.toString = function() {
+    return "LeakData [error=" + this.error + ", dbc=" + this.dbc + ", service=" + this.service + ", profile=" + this.profile + "]";
+};
+
+module.exports = ErrorData;

package/lib/util/escape-literal-sql.js

@@ -173,10 +173,10 @@ EscapeLiteralSQL.prototype._quotation = function () {
             break;
         case STAT.ALPHABET:
             this.parsedSql += this.chars[this.pos];
-            status = STAT.QUOTATION;
+            this.status = STAT.QUOTATION;
             break;
         case STAT.NUMBER:
-            parsedSql += this.chars[this.pos];
+            this.parsedSql += this.chars[this.pos];
             this.status = STAT.QUOTATION;
             break;
         case STAT.QUOTATION:
@@ -194,16 +194,16 @@ EscapeLiteralSQL.prototype._dquotation = function () {
             }
             this.param += this.chars[this.pos];
             this.status = STAT.DQUOTATION;
-            break;;
+            break;
         case STAT.COMMENT:
             this.parsedSql += this.chars[this.pos];
             break;
         case STAT.ALPHABET:
             this.parsedSql += this.chars[this.pos];
-            status = STAT.DQUOTATION;
+            this.status = STAT.DQUOTATION;
             break;
         case STAT.NUMBER:
-            parsedSql += this.chars[this.pos];
+            this.parsedSql += this.chars[this.pos];
             this.status = STAT.DQUOTATION;
             break;
         case STAT.DQUOTATION:

package/lib/util/hashutil.js

@@ -5,9 +5,9 @@
  */
 
 
-var Buffer = require('buffer').Buffer;
+var Buffer  = require('buffer').Buffer;
 
-const CRC_TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
+const CRC_TABLE = [ 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
     0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e,
     0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064,
     0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551,
@@ -49,10 +49,10 @@ const CRC_TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
     0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f,
     0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
     0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02,
-    0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
+    0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d ];
 
-for (var i = 0; i < CRC_TABLE.length; i++) {
-    CRC_TABLE[i] = hexToInt(CRC_TABLE[i].toString(16));
+for(var i = 0 ; i < CRC_TABLE.length; i ++){
+    CRC_TABLE[i] = hexToInt( CRC_TABLE[i].toString(16) );
 }
 
 function hexToInt(hex) {
@@ -68,35 +68,35 @@ function hexToInt(hex) {
 }
 
 var hashUtil = {
-    crc32: function (str) {
+    crc32 : function(str) {
         var buf = Buffer.alloc(str.length);
         buf.write(str, 'utf-8');
         var crc = 0;
         crc = crc ^ (-1);
-        for (var n = 0; n < buf.length; n++) {
+        for ( var n = 0; n < buf.length; n++) {
             crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
         }
         return crc ^ (-1);
     },
-    toStr: function (n, def) {
-        if (n) {
+    toStr: function(n,def){
+        if(n){
             return n.toString();
         }
-        return def ? def : '';
+        return  def? def:'';
     },
-    hashFromString: function (str) {
-        if (str) {
-            return this.hash(Buffer.from(str));
-        } else {
-            return 0;
+    hashFromString: function(str){
+        if(str){
+          return this.hash(Buffer.from(str));
+        }else{
+          return 0;
         }
     },
-    hash: function (bytes /* bytes[] */) {
+    hash: function(bytes /* bytes[] */){
         var crc = -1;
         var var2 = bytes;
         var var3 = bytes.length;
 
-        for (var var4 = 0; var4 < var3; ++var4) {
+        for(var var4 = 0 ; var4 < var3; ++var4){
             var b = var2[var4];
             crc = crc >>> 8 ^ CRC_TABLE[(crc ^ b) & 255];
         }
@@ -104,7 +104,7 @@ var hashUtil = {
         crc = crc ^ 0xffffffff;
         return crc;
     },
-    toInt: function (buf /* buf[] */) {
+    toInt: function(buf /* buf[] */){
         var ch1 = buf[0] & 255;
         var ch2 = buf[1] & 255;
         var ch3 = buf[2] & 255;