readded nodejs-mysql-native to push it to git repository

lib/nodejs-mysql-native/client.js

+
+    var reader = require('./serializers').reader;
+    var writer = require('./serializers').writer;
+    var cmd = require('./commands');
+    var net = require('net');
+    var sys = require('sys');
+    var queue = require('./containers').queue;
+
+    function packetLength(data)
+    {
+        var len = data.charCodeAt(0);
+        len += (data.charCodeAt(1) << 8);
+        len += (data.charCodeAt(2) << 16);
+        return len;
+    }
+
+    exports.createTCPClient = function(host, port)
+    {
+        var host = host ? host : "locahost";
+        var port = port ? port : 3306;
+        var connection = net.createConnection(3306, "localhost");
+        connection.pscache = {};
+        connection.setEncoding("binary");
+        connection.setTimeout(0);
+
+        return new socketClient(connection);
+    }
+
+function dump(d)
+{
+   return;
+   for (var i=0; i < d.length; ++i)
+   {
+       sys.puts(i.toString() + " " + d.charAt(i) + " " + d.charCodeAt(i).toString());
+   }
+}
+
+ 
+    socketClient = function(connection)
+    {
+        var client = this;
+        this.commands = new queue();
+        this.connection = connection;
+        connection.buffer = "";
+
+
+        // TODO: fold following code into somthing without copy-paste
+        this.close = function()
+        {
+            return this.add(new cmd.close());
+        }
+
+        this.debug = function( text )
+        {
+            return this.add(new cmd.debug(text));
+        }
+
+        this.auth = function(dbname, user, password)
+        {
+            return this.add(new cmd.auth(dbname, user, password));
+        }
+
+        this.query = function(q)
+        {
+            return this.add(new cmd.query(q));
+        }
+
+        this.prepare = function(q)
+        {
+            return this.add(new cmd.prepare(q));
+        }
+
+        // TODO: too many copy-paste, cleanup
+        this.execute = function(q, parameters)
+        {
+            if (!this.pscache)
+                this.pscache = {};
+            if (this.auto_prepare == true)
+            {
+                var cached = this.connection.pscache[q];
+                if (!cached) {
+                    var prepare_cmd = this.add(new cmd.prepare(q));
+                    var execute_cmd = this.add(new cmd.execute(q, parameters));
+                    prepare_cmd.addListener('prepared', function(ps) { execute_cmd.ps = ps; });
+                    prepare_cmd.addListener('error', function(err)
+                    {
+                        execute_cmd.emit('error', err);
+                        execute_cmd.prepare_failed = true; 
+                    });
+                    return execute_cmd;
+                } else {
+                    var execute_cmd = this.add(new cmd.execute(q, parameters));
+                    execute_cmd.ps = cached;
+                    return execute_cmd;
+                }
+            }            
+            return this.add(new cmd.execute(q, parameters));
+        }
+
+        this.terminate = function()
+        {
+            this.connection.end();
+        }
+
+        this.write_packet = function(packet, pnum)
+        {
+            packet.addHeader(pnum);
+            this.connection.write(packet.data, 'binary');
+        }
+
+        this.dispatch_packet = function(packet)
+        {
+            if (this.commands.empty())
+                return;
+            if (this.commands.top().process_packet(packet))
+            {
+                this.commands.shift();
+                this.connection.emit('queue', this.commands.length);
+                this.dispatch_packet();
+            }
+        }
+
+        // proxy request to socket eventemitter
+        this.addListener = function()
+        {
+            this.connection.addListener.apply(this.connection, arguments);
+        }
+
+        this.add = function(c)
+        {
+            c.connection = this;
+            var need_start_queue = this.connection.connected && this.commands.empty();
+            this.commands.push(c);
+            this.connection.emit('queue', this.commands.length); 
+            if (need_start_queue)
+                this.dispatch_packet();
+
+            var connection = this.connection;
+            //c.addListener('end', function(cmd) { connection.emit('command_end', c); });
+            //c.addListener('error', function(e) { sys.puts(e.message); });  // TODO: throw exception
+            return c;
+        } 
+
+        this.connection.addListener("data",
+            function(data)
+            {
+                // TODO: move to 'onconnect' event
+                // replace connected with 'first packet' or 'ready state' or smth similar
+                if (!this.connected)
+                {
+                    this.connected = true;
+                    client.dispatch_packet();
+                }
+
+                this.buffer += data;
+                var len = packetLength(this.buffer);
+
+                while (this.buffer.length >= len + 4)
+                {
+                    var packet = this.buffer.substr(4,len);
+                    client.dispatch_packet(new reader(packet) );
+                    this.buffer = this.buffer.substr(len+4, this.buffer.length-len-4);
+                    len = packetLength(this.buffer);
+                }
+            }
+        );
+
+        return client;
+    }
+    

lib/nodejs-mysql-native/commands.js

+var sys = require('sys');
+var writer = require('./serializers').writer;
+var field_flags = require('./constants').field_flags;
+var flags = require('./constants').flags;
+var types = require('./constants').types;
+
+function xor(s1, s2)
+{
+    var res = "";
+    for (var i=0; i < 20; ++i)
+    {
+        var c1 = s1.charCodeAt(i);
+        var c2 = s2.charCodeAt(i);
+        res += String.fromCharCode( s1.charCodeAt(i) ^ s2.charCodeAt(i) );
+    }
+    return res;
+}
+
+function parseTime(s)
+{
+    // TODO: add real parsing
+    return new Date();
+}
+
+function parseString(s)
+{
+    return s;
+}
+
+function parseNull(s)
+{
+    return null;
+}
+
+var type_parsers = {};
+  type_parsers[types.MYSQL_TYPE_DECIMAL] =  parseInt;
+  type_parsers[types.MYSQL_TYPE_TINY] = parseInt;
+  type_parsers[types.MYSQL_TYPE_SHORT] = parseInt;
+  type_parsers[types.MYSQL_TYPE_LONG] = parseInt;
+  type_parsers[types.MYSQL_TYPE_FLOAT] = parseFloat;
+  type_parsers[types.MYSQL_TYPE_DOUBLE] = parseFloat;
+  type_parsers[types.MYSQL_TYPE_NULL] = parseNull,
+  type_parsers[types.MYSQL_TYPE_TIMESTAMP] = parseTime,
+  type_parsers[types.MYSQL_TYPE_LONGLONG] = parseInt;
+  type_parsers[types.MYSQL_TYPE_INT24] = parseInt;
+  type_parsers[types.MYSQL_TYPE_DATE] = parseTime,
+  type_parsers[types.MYSQL_TYPE_TIME] = parseTime,
+  type_parsers[types.MYSQL_TYPE_DATETIME] = parseTime,
+  type_parsers[types.MYSQL_TYPE_YEAR] = parseTime,
+  type_parsers[types.MYSQL_TYPE_NEWDATE] = parseTime,
+  type_parsers[types.MYSQL_TYPE_VARCHAR] = parseString;
+  //MYSQL_TYPE_BIT: ,
+  //MYSQL_TYPE_NEWDECIMAL: 246,
+  //MYSQL_TYPE_ENUM: 247,
+  //MYSQL_TYPE_SET: 248,
+  type_parsers[types.MYSQL_TYPE_TINY_BLOB] = parseString;
+  type_parsers[types.MYSQL_TYPE_MEDIUM_BLOB] = parseString;
+  type_parsers[types.MYSQL_TYPE_LONG_BLOB] = parseString;
+  type_parsers[types.MYSQL_TYPE_BLOB] = parseString;
+  type_parsers[types.MYSQL_TYPE_VAR_STRING] = parseString;
+  type_parsers[types.MYSQL_TYPE_STRING] = parseString;
+  //MYSQL_TYPE_GEOMETRY: 255G
+
+/*
+var type_seriliaers = {};
+type_serialisers['string'] = serialiseString;
+
+function serialiseString(a)
+{
+    var w = new writer();
+    w.lcstring(s);
+    return w.data;
+}
+*/
+
+var string2type = function(str, t)
+{
+    return type_parsers[t](str);
+}
+
+var mysql_type = function(js_type)
+{
+}
+
+
+var crypto = require('crypto');
+function sha1(msg)
+{
+    var hash = crypto.createHash('sha1');
+    hash.update(msg);
+    return hash.digest('binary');
+}
+
+//
+// mysql 4.2+ authorisation protocol
+// token = sha1(salt + sha1(sha1(password))) xor sha1(password)
+//
+function scramble(password, salt)
+{
+    var stage1 = sha1(password);
+    var stage2 = sha1(stage1);
+    var stage3 = sha1(salt + stage2);
+    return xor(stage3, stage1);
+}
+
+
+//
+// base for all commands
+// initialises EventEmitter and implemets state mashine
+//
+function cmd(handlers)
+{
+    var ee = new process.EventEmitter();
+    this.state = "start";
+    // mixin all handlers  
+    for (h in handlers)
+    {
+        if(handlers.hasOwnProperty(h)) 
+        {
+            this[h] = handlers[h];
+        }
+    }    
+
+    // delegate to private EventEmitter member
+    this.emit = function()
+    {
+       ee.emit.apply(ee, arguments);
+    }
+    this.on = this.addListener = function()
+    {
+       ee.addListener.apply(ee, arguments);
+       return this;
+    }
+
+    this.process_packet = function(r)
+    {
+        if (r && r.isErrorPacket())
+        {
+            var error = r.readOKpacket();
+            ee.emit('error', error);
+            return true;
+        }
+ 
+        var next_state = this[this.state].apply(this, arguments);
+        if (next_state)
+        {
+            this.state = next_state;
+        }
+        if (this.state == "done")
+        {
+           ee.emit('end', this);
+           return true;
+        }
+        if (this.state == "error")
+           return true;
+        return false;
+    }
+
+    this.write = function(packet, pnum)
+    {
+        this.connection.write_packet(packet,pnum);    
+    }
+
+    this.store_column = function(r,f,v)
+    {
+        if (this.connection.row_as_hash)
+            r[f.name] = v;
+        else
+            r.push(v);
+    }
+} 
+
+function auth(db, user, password)
+{
+    if (!user)
+        user='';
+    if (!password)
+        password='';
+
+    var c = new cmd( 
+    {
+        start: function() { return 'read_status'; },
+        read_status: function( r )
+        {
+            c.serverStatus.protocolVersion = r.bytes(1);
+            c.serverStatus.serverVersion = r.zstring();
+            c.serverStatus.threadId = r.bytes(4);
+            var salt = r.bytes(8);
+            // TODO: whats this? comment and add fields o sercerStatus
+            r.bytes(1);
+            r.bytes(5);
+            r.bytes(1);
+            r.bytes(12);
+            salt += r.bytes(12);
+
+            var token = scramble(password, salt);
+            var reply = new writer();
+            var client_flags = flags.CLIENT_BASIC_FLAGS;
+            reply.add(client_flags);
+            reply.add(0x01000000);        //max packet length
+            reply.add("\u0008");          //charset
+            var filler = ""; for (var i=0; i < 23; ++i) filler += "\u0000";
+            reply.add(filler);
+            reply.zstring(user);
+            reply.lcstring(token);
+            reply.zstring(db);
+            this.write(reply, 1);
+            return 'check_auth_ok';
+        },
+        check_auth_ok: function( r ) 
+        {
+            var ok = r.readOKpacket();
+            this.emit('authorized', c.serverStatus);
+            return 'done'; 
+        }        
+    });
+    c.state = 'start';
+    c.serverStatus = {};
+    return c;
+}
+
+function query(sql)
+{
+    var c = new cmd(
+    {
+        start: function()
+        {
+            this.write( new writer().add("\u0003").add(this.sql) );
+            return 'rs_ok';
+        },
+        rs_ok: function( r )
+        {
+            var ok = r.readOKpacket();
+            this.insert_id = ok.insert_id;
+            this.affected_rows = ok.affected_rows;
+            if (ok.field_count == 0)
+            { 
+                return 'done';
+            }
+            this.fields = [];
+            return 'handle_fields';
+        },
+        handle_fields: function( r )
+        {
+            if (r.isEOFpacket())
+            {
+                this.emit('fields_eof');
+                return 'data';
+            }
+            var f = r.field();
+            this.emit('field', f);
+            this.fields.push(f);
+        },
+        data: function( r )
+        {
+            if (r.isEOFpacket())
+            {
+                return 'done';
+            }
+
+            var row = this.connection.row_as_hash ? {} : [];
+            var field_index = 0;
+            while (!r.eof())
+            {
+                var field = this.fields[field_index];
+                var value = string2type(r.lcstring(), field.type); // todo: move to serialiser unpackString
+                this.store_column(row, field, value)
+                field_index++;
+            }
+            this.emit('row', row, this.fields);
+        }
+    });
+    c.sql = sql;
+    return c;
+}
+
+function prepare(sql)
+{
+    return new cmd(
+    {
+        start: function()
+        {
+           //if (this.connection.pscache[sql])
+           //    return 'done';
+           this.write( new writer().add("\u0016").add(sql) );
+           return 'ps_ok';
+        },
+        ps_ok: function( r )
+        {
+           this.ps = {};
+           var ok = r.bytes(1);
+           this.ps.statement_handler_id = r.num(4);
+           this.ps.field_count = r.num(2);
+           this.ps.num_params = r.num(2);
+           r.bytes(1); // filler, should be 0
+           
+           if (!this.connection.pscache)
+               this.connection.pscache = {};
+           this.connection.pscache[sql] = this.ps;
+           this.emit('ok', this.ps);
+           this.ps.fields = [];
+           this.ps.parameters = [];
+           if (this.ps.num_params > 0)
+               return 'params';
+           if (this.ps.field_count == 0)
+               return 'done';
+           return 'fields';
+        },
+        params: function( r )
+        {
+            if (r.isEOFpacket())
+            {
+                 if (this.ps.field_count == 0)
+                      return 'done';
+                 return 'fields';
+            }
+            //var p = r.parameter();
+            var p = r.field();
+            this.ps.parameters.push(p);
+        },
+        fields: function( r )
+        {
+            if (r.isEOFpacket())
+            {
+                return 'done';
+            }
+            var f = r.field();
+            this.ps.fields.push(f);
+            this.emit('field', f);
+        }        
+    }
+
+    );
+}
+
+
+function execute(sql, parameters)
+{
+    var ps;
+    return new cmd(
+    {
+        start: function()
+        {
+           if (this.prepare_failed)
+               return 'done';
+
+           if (!this.ps && this.connection.pscache)
+               this.ps = this.connection.pscache[sql];
+           if (!this.ps)
+           {
+               var error = { message: 'Prepared statement \"' + sql + '\" not found', errno: 0 };
+               this.emit('error', error);
+               return 'done';
+           }
+           var packet = new writer().add("\u0017").add(this.ps.statement_handler_id).add("\u0000\u0001\u0000\u0000\u0000");
+           if ( parameters )
+           {
+               var null_bit_map = "";
+               var mask = 1;        
+               var bit_map = 0; 
+               for (var p=0; p < parameters.length; ++p)
+               {
+                   if (parameters[p] == null)
+                       bit_map += mask;
+                   mask = mask*2;
+                   if (mask == 256)
+                   {
+                       null_bit_map += String.fromCharCode(bit_map);
+                       mask = 1;
+                       bit_map = 0;
+                   }
+               }
+               null_bit_map += String.fromCharCode(bit_map);
+
+               packet.add(null_bit_map);
+               // todo: set types only on first call
+               packet.add('\u0001');
+               // todo: add numeric/datetime serialisers
+               for (var i = 0; i < parameters.length; i++)
+               {
+                   if (parameters[i] != null)
+                       packet.int2(types.MYSQL_TYPE_VAR_STRING);
+               }
+               for (var i = 0; i < parameters.length; i++)
+               {
+                   if (parameters[i] != null)
+                       packet.lcstring(parameters[i].toString());
+               }                          
+           }
+           this.write( packet ); 
+           return 'execute_ok';
+        },
+        execute_ok: function(r)
+        {
+           var ok = r.readOKpacket();
+           this.insert_id = ok.insert_id;
+           this.affected_rows = ok.affected_rows;
+           if (this.ps.field_count == 0)
+               return 'done';
+           return 'fields';
+        },
+        fields: function( r )
+        {
+            if (r.isEOFpacket())
+            {
+                this.emit('fields_eof');
+                return 'binrow';
+            }
+            var f = r.field();
+            this.emit('field', f);
+        },
+        binrow: function( r )
+        {
+            if (r.isEOFpacket())
+               return 'done';
+
+            var null_bit_map = [];
+            r.num(1); // first octet always 0
+            var bit = 4;
+            var bitmap_byte;
+            if (this.ps.field_count > 0)
+                bitmap_byte = r.num(1);
+            for (var f=0; f < this.ps.field_count; ++f)
+            {
+                null_bit_map.push( (bitmap_byte & bit) != 0);
+                if (!((bit<<=1) & 255))
+                {
+                    bit= 1;
+                    bitmap_byte = r.num(1);
+                }    
+            }
+            var row = this.connection.row_as_hash ? {} : [];
+            for (var f=0; f < this.ps.field_count; ++f)
+            {
+                var field = this.ps.fields[f];
+                if (!null_bit_map[f])
+                {
+                    var value = r.unpackBinary(field.type, field.flags & field_flags.UNSIGNED);
+                    this.store_column(row, field, value);
+                } else {
+                    this.store_column(row, field, null);
+                }
+            }
+            this.emit('row', row);
+        }
+
+    });
+}
+
+function close()
+{
+   return new cmd(
+       {
+          start: function()
+          {
+              this.connection.terminate();
+              return 'done';
+          }
+      }
+   );
+}
+
+function debug( text )
+{
+   return new cmd(
+       {
+          start: function()
+          {
+              sys.puts(text);
+              return 'done';
+          }
+      }
+   );
+}
+
+exports.auth = auth;
+exports.close = close;
+exports.query = query;
+exports.prepare = prepare;
+exports.execute = execute;
+exports.debug = debug;

lib/nodejs-mysql-native/constants.js

+var flags = exports.flags = 
+{
+  CLIENT_LONG_PASSWORD:	1	,/* new more secure passwords */
+  CLIENT_FOUND_ROWS:	2	,/* Found instead of affected rows */
+  CLIENT_LONG_FLAG:	4	,/* Get all column flags */
+  CLIENT_CONNECT_WITH_DB:	8	,/* One can specify db on connect */
+  CLIENT_NO_SCHEMA:	16	,/* Don't allow database.table.column */
+  CLIENT_COMPRESS:		32	,/* Can use compression protocol */
+  CLIENT_ODBC:		64	,/* Odbc client */
+  CLIENT_LOCAL_FILES:	128	,/* Can use LOAD DATA LOCAL */
+  CLIENT_IGNORE_SPACE:	256	,/* Ignore spaces before '(' */
+  CLIENT_PROTOCOL_41:	512	,/* New 4.1 protocol */
+  CLIENT_INTERACTIVE:	1024	,/* This is an interactive client */
+  CLIENT_SSL:              2048	,/* Switch to SSL after handshake */
+  CLIENT_IGNORE_SIGPIPE:   4096    ,/* IGNORE sigpipes */
+  CLIENT_TRANSACTIONS:	8192	,/* Client knows about transactions */
+  CLIENT_RESERVED:         16384   ,/* Old flag for 4.1 protocol  */
+  CLIENT_SECURE_CONNECTION: 32768  ,/* New 4.1 authentication */
+  CLIENT_MULTI_STATEMENTS: 65536   ,/* Enable/disable multi-stmt support */
+  CLIENT_MULTI_RESULTS:    131072  /* Enable/disable multi-results */
+}
+
+exports.field_flags = 
+{
+    NOT_NULL:   1,               /* Field can't be NULL */
+    PRI_KEY:    2,               /* Field is part of a primary key */
+    UNIQUE_KEY: 4,               /* Field is part of a unique key */
+    MULTIPLE_KEY: 8,             /* Field is part of a key */
+    BLOB:       16,              /* Field is a blob */
+    UNSIGNED:   32,              /* Field is unsigned */
+    ZEROFILL:   64,              /* Field is zerofill */
+    BINARY:     128, 
+}
+
+exports.flags.CLIENT_BASIC_FLAGS = flags.CLIENT_LONG_PASSWORD | 
+                       flags.CLIENT_FOUND_ROWS | 
+                       flags.CLIENT_LONG_FLAG | 
+                       flags.CLIENT_CONNECT_WITH_DB | 
+                       flags.CLIENT_NO_SCHEMA | 
+                       flags.CLIENT_ODBC | 
+                       flags.CLIENT_LOCAL_FILES | 
+                       flags.CLIENT_IGNORE_SPACE | 
+                       flags.CLIENT_PROTOCOL_41 | 
+                       flags.CLIENT_INTERACTIVE |
+                       flags.CLIENT_IGNORE_SIGPIPE | 
+                       flags.CLIENT_TRANSACTIONS | 
+                       flags.CLIENT_RESERVED | 
+                       flags.CLIENT_SECURE_CONNECTION | 
+                       flags.CLIENT_MULTI_STATEMENTS | 
+                       flags.CLIENT_MULTI_RESULTS;  
+
+exports.types = 
+{
+  MYSQL_TYPE_DECIMAL: 0,
+  MYSQL_TYPE_TINY: 1,
+  MYSQL_TYPE_SHORT: 2,
+  MYSQL_TYPE_LONG: 3,
+  MYSQL_TYPE_FLOAT: 4,
+  MYSQL_TYPE_DOUBLE: 5,
+  MYSQL_TYPE_NULL: 6,
+  MYSQL_TYPE_TIMESTAMP: 7,
+  MYSQL_TYPE_LONGLONG: 8,
+  MYSQL_TYPE_INT24: 9,
+  MYSQL_TYPE_DATE: 10,
+  MYSQL_TYPE_TIME: 11,
+  MYSQL_TYPE_DATETIME: 12,
+  MYSQL_TYPE_YEAR: 13,
+  MYSQL_TYPE_NEWDATE: 14,
+  MYSQL_TYPE_VARCHAR: 15,
+  MYSQL_TYPE_BIT: 16,
+  MYSQL_TYPE_NEWDECIMAL: 246,
+  MYSQL_TYPE_ENUM: 247,
+  MYSQL_TYPE_SET: 248,
+  MYSQL_TYPE_TINY_BLOB: 249,
+  MYSQL_TYPE_MEDIUM_BLOB: 250,
+  MYSQL_TYPE_LONG_BLOB: 251,
+  MYSQL_TYPE_BLOB: 252,
+  MYSQL_TYPE_VAR_STRING: 253,
+  MYSQL_TYPE_STRING: 254,
+  MYSQL_TYPE_GEOMETR: 255
+};
+
+exports.type_names = {};
+
+for (var tname in exports.types)
+{
+   if(exports.types.hasOwnProperty(tname) )
+   {
+       var type = exports.types[tname];
+       exports.type_names[type] = tname;
+   }
+}

lib/nodejs-mysql-native/containers.js

+// doubly-linked list for constant time shift
+// each node have prev,next,data properties
+
+var sys = require('sys');
+
+function deque()
+{
+    this.begin = null;
+    this.end = null;
+    this.length = 0;
+}
+
+deque.prototype.push = function(data)
+{
+    if (!this.begin) // insert into empty list
+    {
+        this.begin = this.end = { 'data': data };
+        this.begin.next = this.begin; 
+        this.begin.prev = this.begin; 
+    } else {
+        var end = this.end;
+        this.end = { 'data': data };
+        this.end.prev = end;
+        end.next = this.end;
+    }
+    ++this.length;
+    return this;
+}
+
+deque.prototype.top = function()
+{
+    if (this.begin)
+        return this.begin.data;
+}
+
+deque.prototype.empty = function()
+{
+    return this.length == 0;
+}
+
+deque.prototype.shift = function()
+{
+    --this.length;
+    if (this.begin == this.end)
+    {
+        this.begin = this.end = null;
+        return this.begin;
+    }
+    var res = this.begin.data;
+    this.begin = this.begin.next;
+    return res;
+}
+
+exports.queue = deque;

lib/nodejs-mysql-native/pool.js

+var queue = require('./containers').queue;
+var sys= require('sys');
+
+function pool(newConnectionFactory, minConnections)
+{
+   this.newConnectionFactory = newConnectionFactory;
+
+   // some reasonable defaults
+   if (minConnections)
+       this.minConnections = minConnections; // lazy by default 
+   else
+       this.minConnections = 0;
+   this.maxConnections = 16;
+   this.maxQueue = 2; // increase if average command time is much shorter compared to connect time
+                      // TODO: calculate ratio on the fly? think of adaptiveMaxQueue
+   this.idleTimeout = 0; // TODO: also possible to make adaptive
+   this.maxWaiters = 100000000; // TODO: infinity?
+
+   this.waiters = new queue();
+   this.connections = new queue();
+   for (var i=0; i <= this.minConnections; ++i)
+      this.spawnConnection();
+}
+
+pool.prototype.spawnConnection = function()
+{
+    var client = this.newConnectionFactory();
+    var self = this;
+    // todo: Qt-style connection-slot api?
+    client.connection.addListener('queue', function(new_size) { self.queueChanged(client, new_size); });
+    var node = this.connections.push(client);
+    client.pool_node = node;
+    return client;
+}
+
+pool.prototype.queueChanged = function(client, new_size)
+{
+    if (new_size != 0)
+        return;
+
+
+    sys.puts('queue event ' + new_size);
+    //var new_size = client.commands.length;
+
+    // if (new_size == 1)
+    //    sys.p(client.commands.begin.data);
+    // sys.puts("New queue:" + new_size);
+
+    if (!this.waiters.empty() && new_size == 0) //<= this.maxQueue)
+    {
+        var w = this.waiters.shift();
+        sys.puts("free connection released to waiter" );
+        if (w)
+            w(client);
+    }
+
+    // there is no commands left for current connection
+    // close it after idleTimeout
+    if (new_size == 0 && this.connections.length > this.minConnections)
+    {
+        if (this.idleTimeout > 0)
+        {
+            //todo: add close timer
+        } else {
+            client.close();
+        }
+    }
+
+    // calculate new index
+}
+
+pool.prototype.get = function(onClientReady)
+{
+    sys.puts("=== pool::get === ");
+    // select client with minimal queue
+    // if its queue length <= maxQueue, return it
+    // if connections size less than maxConnection, spawn a new connection
+    // else enqueue request
+    // throw error if waiters queue length > maxWaiters
+
+
+    // quick hack
+    // TODO: add search using index
+    var minQueueConnection = null;
+    var minQueue = 1000000000;
+    for (var i = this.connections.begin; i != this.connections.end; i = i.next)
+    {
+        var cli = i.data;
+        var len = cli.commands.length;
+        sys.puts("client q:" + len);
+        if (len < minQueue)
+        {
+            minQueue = len;
+            minQueueConnection = cli;
+        }
+    }
+    sys.puts("min pool queue is " + minQueue);
+    if (minQueue <= this.maxQueue)
+    {
+        sys.puts("using existing connection");
+        return onClientReady(minQueueConnection);
+    }
+    if (this.connections.length < this.maxConnections)
+    {
+        sys.puts("sapwning new connection");
+        return onClientReady(this.spawnConnection());
+    }
+    if (this.waiters.length < this.maxWaiters)
+    {
+        sys.puts("waiting for awailable connection");
+        this.waiters.push(onClientReady);
+        return;
+    }
+}
+/*
+pool.prototype.close = function()
+{
+    for (var i = this.connections.begin; i != this.connections.end; i = i.next)
+    {
+        i.data.close();
+    }
+}
+*/
+
+exports.pool = pool;

lib/nodejs-mysql-native/serializers.js

+var sys = require('sys');
+var constants = require('./constants');
+
+function writer()
+{
+   this.data = "";
+}
+
+writer.prototype.zstring = function(s)
+{
+   this.data += s + "\u0000";
+   return this;
+}
+
+//
+//  length-coded number
+//
+//  Value Of     # Of Bytes  Description
+//  First Byte   Following
+//  ----------   ----------- -----------
+//  0-250        0           = value of first byte
+//  251          0           column value = NULL
+//                           only appropriate in a Row Data Packet
+//  252          2           = value of following 16-bit word
+//  253          3           = value of following 24-bit word
+//  254          8           = value of following 64-bit word
+//
+writer.prototype.lcnum = function(n)
+{
+   if (n < 251)
+       this.data += String.fromCharCode(n);
+   else if (n < 0xffff)
+   {
+       this.data += String.fromCharCode(252);
+       this.data += String.fromCharCode( n & 0xff );
+       this.data += String.fromCharCode( (n >> 8) & 0xff );
+   } else if (n < 0xffffff)
+   {
+       this.data += String.fromCharCode(253);
+       this.data += String.fromCharCode( n & 0xff );
+       this.data += String.fromCharCode( (n >> 8) & 0xff );
+       this.data += String.fromCharCode( (n >> 16) & 0xff );
+   } 
+   /*
+      TODO: 64 bit number
+   */
+   return this;
+}
+
+//
+// write length-coded string to the buffer
+//
+writer.prototype.lcstring = function(s)
+{
+   this.lcnum(s.length);
+   this.data += s;
+   return this;
+}
+
+writer.prototype.add = function(s)
+{
+   if (typeof s == "string")      // add string bufer
+       this.data += s; 
+   else if (typeof s == "number") // add four byte integer
+   {
+       this.data += String.fromCharCode( s & 0xff );
+       this.data += String.fromCharCode( (s >> 8)  & 0xff );
+       this.data += String.fromCharCode( (s >> 16) & 0xff );
+       this.data += String.fromCharCode( (s >> 24) & 0xff );
+   }
+   return this;
+}
+
+writer.prototype.int2 = function(s)
+{
+    this.data += String.fromCharCode( s & 0xff );
+    this.data += String.fromCharCode( (s >> 8)  & 0xff );
+}
+
+writer.prototype.addHeader = function(n)
+{
+    var length = this.data.length;
+    var header = "";
+    header += String.fromCharCode( length     & 0xff );
+    header += String.fromCharCode( length>>8  & 0xff );
+    header += String.fromCharCode( length>>16 & 0xff );
+    var packet_num = n ? n : 0;
+    header += String.fromCharCode( packet_num );
+    this.data = header + this.data;
+    return this;
+}
+
+function reader(data)
+{
+   this.data = data;
+   this.pos = 0;
+
+}
+
+// libmysql sets all fields to zero when binary packet has zero length
+function zeroTime()
+{
+   // todo: check how zero date is serialized to output in mysql
+   return new Date(); 
+}
+
+reader.prototype.unpackBinaryTime = function()
+{
+    var length = this.lcnum();
+    if (length == 0)
+       return zeroTime();
+    var sign = this.num(1);
+    var day = this.num(4);
+    var hour = this.num(1);
+    var minutes = this.num(1);
+    var seconds = this.num(1);
+    var millisec = (length > 8) ? this.num(4) : 0;
+    if (day != 0)
+        hour += day*24;
+    var millisec_time_val = millisec + seconds*1000 + minutes*60000 + hour*3600000;
+    if (sign != 0)
+        millisec_time_val *= -1;
+    return millisec_time_val;
+}
+
+reader.prototype.unpackBinaryDateTime = function()
+{
+    var length = this.lcnum();
+    if (length == 0)
+       return zeroTime();
+
+    var y = this.num(2);
+    var m = this.num(1);
+    var d = this.num(1);
+
+    var hour = 0;
+    var min = 0;
+    var sec = 0;
+    if (length > 4)
+    {
+       hour = this.num(1);
+       min = this.num(1);
+       sec = this.num(1);
+    }
+    var millisec = (length > 8) ? this.num(4) : 0;
+    var dt = new Date();
+    dt.setYear(y);
+    dt.setMonth(m); 
+    dt.setDate(d);
+    dt.setHours(hour);
+    dt.setMinutes(min);
+    dt.setSeconds(sec);
+    dt.setMilliseconds(millisec);
+    return dt;
+}
+
+reader.prototype.unpackBinaryDate = function()
+{
+    var length = this.lcnum();
+    if (length == 0)
+       return zeroTime();
+
+    var y = this.num(2);
+    var m = this.num(1);
+    var d = this.num(1);
+    var dt = new Date();
+    dt.setYear(y);
+    dt.setMonth(m); 
+    dt.setDate(d);
+
+    return dt;
+}
+
+// deserialise mysql binary field
+reader.prototype.unpackBinary = function(type, unsigned)
+{
+    // debug dump
+    //return "_not_implemented_ " + constants.type_names[type] + " " + sys.inspect(this.data);
+
+    var result;
+    switch (type)
+    {
+    case constants.types.MYSQL_TYPE_STRING:
+    case constants.types.MYSQL_TYPE_VAR_STRING:
+    case constants.types.MYSQL_TYPE_BLOB:
+        result = this.lcstring();
+        break;
+    case constants.types.MYSQL_TYPE_LONG:
+        result = this.num(4);
+        break;
+    case constants.types.MYSQL_TYPE_LONGLONG:
+        result = this.num(8);
+        break;
+    case constants.types.MYSQL_TYPE_NEWDECIMAL:
+        result = parseFloat(this.lcstring());
+        break;
+/*
+  MYSQL_TYPE_TIMESTAMP: 7,
+  MYSQL_TYPE_LONGLONG: 8,
+  MYSQL_TYPE_INT24: 9,
+  MYSQL_TYPE_DATE: 10,
+  MYSQL_TYPE_TIME: 11,
+  MYSQL_TYPE_DATETIME: 12,
+  MYSQL_TYPE_YEAR: 13,
+  MYSQL_TYPE_NEWDATE: 14,
+
+*/
+    case constants.types.MYSQL_TYPE_DATE:
+         return this.unpackBinaryDate();
+    case constants.types.MYSQL_TYPE_TIME:
+         return this.unpackBinaryTime();
+    case constants.types.MYSQL_TYPE_DATETIME:
+    case constants.types.MYSQL_TYPE_TYMESTAMP:
+         return this.unpackBinaryDateTime();
+    default:
+        result = "_not_implemented_ " + constants.type_names[type] + " " + sys.inspect(this.data); //todo: throw exception here
+    }
+    return result;
+}
+
+// read n-bytes number 
+reader.prototype.num = function(numbytes)
+{
+    var res = 0;
+    var factor = 1;
+    for (var i=0; i < numbytes; ++i)
+    {
+        res += this.data.charCodeAt(this.pos) * factor;
+        factor = factor << 8;
+        this.pos++;
+    }
+    return res;
+}
+
+reader.prototype.field = function()
+{
+   var field = {};
+   field.catalog = this.lcstring();
+   field.db = this.lcstring();
+   field.table = this.lcstring();
+   field.org_table = this.lcstring();
+   field.name = this.lcstring();
+   field.org_name = this.lcstring();
+   field.filler = this.num(1);
+   field.charsetnum = this.num(2);
+   field.length = this.num(4);
+   field.type = this.num(1);
+   field.flags = this.num(2);
+   field.decimals = this.num(1);
+   field.filler = this.num(2);
+   field.defval = this.lcstring();
+   return field;
+}
+
+function binary(n)
+{
+    var res = "";
+    var nbits = 0;
+    while(n != 0)
+    {
+        var bit = n - Math.floor(n/2)*2;
+        res = bit + res;
+        n = Math.floor(n/2);
+        nbits++;
+    }
+    for(; nbits <= 8; ++nbits)
+         res = "0" + res;    
+    return res;
+}
+
+reader.prototype.zstring = function()
+{
+   var res = "";
+   var c;
+   while(c = this.data.charCodeAt(this.pos++))
+   {
+       res += String.fromCharCode(c);
+   }
+   return res;
+}
+
+reader.prototype.lcstring = function()
+{
+    var len = this.lcnum();
+    var res = this.bytes(len);
+    return res;
+}
+
+reader.prototype.isEOFpacket = function()
+{
+    return this.data.charCodeAt(0) == 254 && this.data.length < 9
+}
+
+reader.prototype.eof = function()
+{
+    return this.pos >= this.data.length;
+}
+
+reader.prototype.tail = function()
+{
+    var res = this.data.substr(this.pos, this.data.length - this.pos);
+    this.pos = this.data.length;
+    return res;
+}
+
+reader.prototype.isErrorPacket = function()
+{
+    return this.data.charCodeAt(0) == 0xff;
+}
+
+reader.prototype.readOKpacket = function()
+{
+   var res = {};
+   res.field_count = this.data.charCodeAt(this.pos++);
+   if (res.field_count == 0xff) // error
+   {
+       res.errno = this.data.charCodeAt(this.pos) + (this.data.charCodeAt(this.pos+1)<<8);
+       this.pos += 8;
+       //this.pos++; // skip sqlstate marker, "#"
+       //res.sqlstate = this.bytes(5);
+   } else {
+       res.affected_rows = this.lcnum();
+       res.insert_id = this.lcnum();
+       res.server_status = this.num(2);
+       res.warning_count = this.num(2);
+   }
+   res.message = this.tail();
+   return res;
+}
+
+reader.prototype.lcnum = function()
+{
+   var b1 = this.data.charCodeAt(this.pos);
+   this.pos++;
+   if (b1 < 251)
+       return b1;
+   else if (b1 == 252)
+       return this.num(2);
+   else if (b1 == 253)
+       return this.num(3);
+   else if (b1 == 254)
+       return this.num(8);   
+}
+
+reader.prototype.readPacketHeader = function()
+{
+   var res = { length: 0, packetNum:0 };
+   res.length += this.data.charCodeAt(0);
+   res.length += this.data.charCodeAt(1) << 8;
+   res.length += this.data.charCodeAt(2) << 16;
+   res.packetNum = this.data.charCodeAt(3);
+   this.pos += 4;
+   return res;
+}
+
+reader.prototype.bytes = function(n)
+{
+   var res = "";
+   var end = this.pos+n;
+   while(this.pos < end)
+   {
+       res += this.data.charAt(this.pos);
+       this.pos++;
+   }
+   return res;
+}
+
+exports.reader = reader;
+exports.writer = writer;

lib/nodejs-mysql-native/websql.js

+// wrappers to provide WebSql-alike interface to mysql
+
+var createTCPClient = require('./client').createTCPClient;
+var sys = require('sys');
+
+function transaction(connection)
+{
+    this.connection = connection;
+}
+
+transaction.prototype.executeSql = function (query, args, rsCallback, errorCallback)
+{
+    var tx = this;
+    if (!tx.clean)
+    {
+        sys.puts("skipped due to errors");
+        return;
+    }
+    var execCmd = this.connection.execute(query, args);
+    var results = {};
+    results.rows = [];
+    this.connection.row_as_hash = true;
+    execCmd.addListener('row', function(r) {
+        results.rows.push(r);
+    });
+    execCmd.addListener('end', function() { if (tx.clean && rsCallback) rsCallback(tx, results); });
+    execCmd.addListener('error', function(err)
+    { 
+       tx.clean = false; 
+       if (errorCallback) 
+          errorCallback(tx, err);
+       if (tx.onerror)
+           tx.onerror(err); 
+    });
+    tx.last_exec_cmd = execCmd;
+}
+
+exports.openDatabase = function(db, user, password)
+{
+    var webdb = {};
+    var connection = createTCPClient();
+    connection.auth(db, user, password);
+    connection.query('SET autocommit=0;');
+    connection.auto_prepare = true;
+    webdb.transaction = function(txCreated, txError)
+    {
+        var t = new transaction(connection);
+        t.onerror = txError;
+        connection.query('BEGIN');
+        t.clean = true;
+        txCreated(t);
+        var commit = connection.query("");
+        t.last_exec_cmd.addListener('end', function()
+        {   
+            commit.sql = t.clean ? "COMMIT" : "ROLLBACK"
+       });
+    }
+    webdb.close = function() { connection.close(); };
+    return webdb;
+}