├── .gitignore
├── AUTHORS
├── LICENSE
├── README.md
├── api.md
├── examples
    ├── nodeman
    │   ├── README
    │   ├── config.js
    │   ├── get_apidoc.js
    │   ├── import.js
    │   ├── index.html
    │   ├── server.js
    │   └── style.css
    ├── simple1.js
    └── speedtest.js
├── lib
    ├── mysql.js
    └── mysql
    │   ├── auth.js
    │   ├── charset.js
    │   ├── connection.js
    │   ├── constants.js
    │   ├── errors.js
    │   ├── node-promise.js
    │   ├── node-socket.js
    │   ├── pack.js
    │   ├── packet.js
    │   ├── protocol.js
    │   ├── result.js
    │   ├── sha1.js
    │   ├── types.js
    │   └── utils.js
└── test
    ├── config.js
    ├── fixtures
        └── data1.csv
    ├── helper.js
    ├── mysql_stub.js
    ├── test.real_mysql.js
    └── test.stub.js


/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | 
3 | 


--------------------------------------------------------------------------------
/AUTHORS:
--------------------------------------------------------------------------------
 1 | # Authors ordered by first contribution.
 2 | 
 3 | Yuichiro MASUI <masui@masuidrive.jp>
 4 | Scott González <scott.gonzalez@gmail.com>
 5 | Delyan Angelov <delian66@gmail.com>
 6 | Oleg Efimov <efimovov@gmail.com>
 7 | Peter Rekdal Sunde <peter.sunde@gmail.com>
 8 | mape <http://github.com/mape>
 9 | Ben Trask <bentrask@comcast.net>
10 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2010 Yuichiro MASUI <masui@masuidrive.jp>
 2 |  
 3 | Permission is hereby granted, free of charge, to any person obtaining
 4 | a copy of this software and associated documentation files (the
 5 | "Software"), to deal in the Software without restriction, including
 6 | without limitation the rights to use, copy, modify, merge, publish,
 7 | distribute, sublicense, and/or sell copies of the Software, and to
 8 | permit persons to whom the Software is furnished to do so, subject to
 9 | the following conditions:
10 |  
11 | The above copyright notice and this permission notice shall be
12 | included in all copies or substantial portions of the Software.
13 |  
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # node-mysql
  2 | 
  3 | *This library is obsolete.*
  4 | 
  5 | *please check [https://github.com/felixge/node-mysql](https://github.com/felixge/node-mysql)*
  6 | 
  7 | 
  8 | node-mysql is pure Javascript MySQL network driver for [node.js](http://nodejs.org/)
  9 | 
 10 | 
 11 | # Want to help
 12 | It's for testing stage.
 13 | Now It can use for this driver developer only.
 14 | 
 15 | I have a lot of tasks to make stable driver.
 16 | I want your help.
 17 | 
 18 | ## Tests
 19 | I need your help in testing this driver. It will be great if you use it for testing or prototyping.
 20 | It's testing stage, It's not for real project
 21 | If you find bugs, strange thing and unknown things, please send them to [@masuidrive_en](http://twitter.com/masuidrive_en) or [github issues](http://github.com/masuidrive/node-mysql/issues)
 22 | If you write test code (test folder), It's awesome!!
 23 | 
 24 | ## Documentation
 25 | 
 26 | Sorry, This driver's documentation is less.
 27 | My English skill is horrible. :-(
 28 | 
 29 | This drivers is came from Ruby's mysql driver.
 30 | Almost API is same as [mysql.rb](http://github.com/tmtm/ruby-mysql/blob/2.9/lib/mysql.rb). maybe [this document](http://tmtm.org/en/mysql/ruby/) is useful reference.
 31 | 
 32 | 
 33 | ## Pool mananager
 34 | Currently, this driver supported single connection only.
 35 | We need multi mysql driver pool manager for multi connections.
 36 | And connection pool require transaction support.
 37 | 
 38 | 
 39 | # Example
 40 | 
 41 |     var sys = require('sys');
 42 |     var mysql = require('./lib/mysql');
 43 |     
 44 |     /*
 45 |     > mysql -u root
 46 |     CREATE DATABASE nodejs_mysql;
 47 |     GRANT ALL ON nodejs_mysql.* TO nodejs_mysql@localhost IDENTIFIED BY "nodejs_mysql";
 48 |     */
 49 |     var conn = new mysql.Connection('localhost','nodejs_mysql', 'nodejs_mysql', 'nodejs_mysql');
 50 |     conn.connect();
 51 |     conn.query("CREATE TEMPORARY TABLE test1(intval INTEGER, strval TEXT, timestampval TIMESTAMP, boolval BOOLEAN);");
 52 |     conn.query("INSERT INTO test1 VALUES(1,'a',now(),true);");
 53 |     conn.query("SELECT * FROM test1;",
 54 |         function(result) {
 55 |             for(var i=0; i<result.records.length; ++i) {
 56 |                 sys.puts("Result: "+sys.inspect(result.toHash(result.records[i])));
 57 |             };
 58 |         },
 59 |         function(error) {
 60 |             sys.puts("Error: "+sys.inspect(error));
 61 |         });
 62 | 
 63 | And see exmaples folder.
 64 | 
 65 | 
 66 | # Requirements
 67 | 
 68 | * [node.js](http://nodejs.org/) >= 0.1.92
 69 | 
 70 | 
 71 | Optional:
 72 | 
 73 | * [node-crypt](http://github.com/waveto/node-crypto) for faster authenticate.
 74 | 
 75 | 
 76 | # License
 77 | 
 78 | MIT License. See LICENSE file.
 79 | 
 80 | 
 81 | # Who?
 82 | 
 83 | Code by Yuichiro MASUI(masuidrive) and awesome contributers.
 84 | please see [AUTHORS](http://github.com/masuidrive/node-mysql/blob/master/AUTHORS)
 85 | 
 86 | * <masui@masuidrive.jp>
 87 | * [http://blog.masuidrive.jp/](http://masuidrive.com/) (English)
 88 | * [http://twitter.com/masuidrive_en](http://twitter.com/masuidrive_en/) (English)
 89 | * [http://blog.masuidrive.jp/](http://blog.masuidrive.jp/) (Japanese)
 90 | * [http://twitter.com/masuidrive](http://twitter.com/masuidrive/) (Japanese)
 91 | 
 92 | 
 93 | # Related licenses
 94 | 
 95 | MySQL protocol encode/decode from tmtm's ruby-mysql.
 96 | 
 97 | * [http://github.com/tmtm/ruby-mysql](http://github.com/tmtm/ruby-mysql)
 98 | * Copyright: Copyright (c) 2009-2010 TOMITA Masahiro 
 99 | * License: Ruby's
100 | 
101 | Promise library
102 | 
103 | * [http://nodejs.org/](http://nodejs.org/)
104 | * Copyright 2009, 2010 Ryan Lienhart Dahl. All rights reserved.
105 | * License: MIT
106 | 
107 | SHA1 library from Takanori Ishikawa.
108 | 
109 | * [http://www.metareal.org/](http://www.metareal.org/)
110 | * Copyright (c) 2008  Takanori Ishikawa  <takanori.ishikawa@gmail.com>
111 | * License: MIT
112 | 
113 | pack/unpack from php.js
114 | 
115 | * [http://phpjs.org/functions/pack:880](http://phpjs.org/functions/pack:880)
116 | * Author: Tim de Koning (http://www.kingsquare.nl)
117 | * License: BSD
118 | 
119 | 


--------------------------------------------------------------------------------
/api.md:
--------------------------------------------------------------------------------
  1 | # mysql-node API reference
  2 | ## Common
  3 | ### callback
  4 | ### errback
  5 | 
  6 | ## Connection
  7 | 
  8 | ### Events
  9 | 
 10 | * connect 
 11 | * close
 12 | * authorized
 13 | * authorize error
 14 | 
 15 | 
 16 | ### Connection(hostname, username, password, dbname, port)
 17 |  It return Connectino object. It not connect to mysqld. 
 18 | 
 19 | ### Connection.quote(string)
 20 |  quote string for SQL.
 21 | 
 22 | ### Connection.prototype.connect(callback, errback)
 23 |  connect to mysqld.
 24 | 
 25 | ### Connection.prototype.close()
 26 |  close connection.
 27 | 
 28 | ### Connection.prototype.timeout(msec)
 29 |  set timeout.
 30 | 
 31 | ### Connection.prototype.autocommit(flag, callback, errback)
 32 |  set/reset autocommit flag.
 33 | 
 34 | ### Connection.prototype.query(sql, callback, errback)
 35 |  do query and return Result object.
 36 | 
 37 | ### Connection.prototype.extract_placeholder(sql)
 38 | 
 39 | 
 40 | ### Connection.prototype.set_server_option(opt)
 41 | 
 42 | 
 43 | ### Connection.prototype.get_result(fields)
 44 | 
 45 | 
 46 | ### Connection.prototype.has_more_results()
 47 |  returns true if more results exist from the currently executed query.
 48 | 
 49 | ### Connection.prototype.next_result(callback, errback)
 50 |  
 51 | 
 52 | 
 53 | ### Connection.prototype.prepare(str, callback, errback)
 54 |  execute prepared statement and return Stmt object.
 55 | 
 56 | 
 57 | 
 58 | ## Result
 59 | Result set.
 60 | 
 61 | ### Result.prototype.fetch_all()
 62 | 
 63 | 
 64 | ### Result.prototype.toHash(row)
 65 | 
 66 | 
 67 | ### Result.prototype.fields
 68 | 
 69 | 
 70 | ### Result.prototype.fieldname_with_table
 71 | 
 72 | 
 73 | 
 74 | 
 75 | 
 76 | ## Stmt
 77 | Prepared statement.
 78 | 
 79 | ### Stmt(rotocol, charset)
 80 | 
 81 | 
 82 | ### Stmt.prototype.close()
 83 | 
 84 | 
 85 | ### Stmt.prototype.prepare(query, callback, errback)
 86 | 
 87 | 
 88 | ### Stmt.prototype.execute(args, callback, errback)
 89 | 
 90 | 
 91 | 
 92 | 
 93 | ## Field
 94 | Field information.
 95 | 
 96 | ### Field.prototype.is_num()
 97 | 
 98 | 
 99 | ### Field.prototype.is_not_null()
100 | 
101 | 
102 | ### Field.prototype.is_pri_key()
103 | 
104 | 
105 | 


--------------------------------------------------------------------------------
/examples/nodeman/README:
--------------------------------------------------------------------------------
1 | * nodejs manual
2 | 
3 | node get_apidoc.js
4 | node import.js < api.json
5 | node server
6 | 
7 | open "http://localhost:8000" on your browser.
8 | 


--------------------------------------------------------------------------------
/examples/nodeman/config.js:
--------------------------------------------------------------------------------
1 | exports.mysql = {
2 |     'hostname': 'localhost',
3 |     'port': 3306,
4 |     'database': 'nodeman',
5 |     'username': 'nodeman',
6 |     'password': 'nodeman'
7 | };
8 | 


--------------------------------------------------------------------------------
/examples/nodeman/get_apidoc.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | var fs = require("fs");
 3 | var sys = require('sys');
 4 | var http = require('http');
 5 | try { 
 6 |     var libxml = require('libxmljs');
 7 | }
 8 | catch(e) {
 9 |     sys.puts("This script required libxmljs");
10 |     sys.puts("Please install http://libxmljs.squishtech.com/");
11 |     process.exit();
12 | }
13 | var config = require('./config');
14 | 
15 | var makeAnchor = function(str) {
16 |     return str.toLowerCase().replace(/[^a-z0-9]/gi, '_');
17 | }
18 | 
19 | var modules = [];
20 | var nodejsorg = http.createClient(80, "nodejs.org");
21 | var request = nodejsorg.request("GET", "/api.html", {"host": "nodejs.org"});
22 | request.addListener('response', function (response) {
23 |     if(response.statusCode!=200) {
24 | 	sys.puts("Can't load api.txt");
25 | 	process.exit();
26 |     }
27 |     
28 |     var body = '';
29 |     response.setBodyEncoding("utf8");
30 |     response.addListener("data", function (chunk) {
31 | 	body += chunk;
32 |     });
33 |     response.addListener("end", function () {
34 | 	body = body.replace(/\r\n/g, "\n");
35 | 	// Create json
36 | 	var doc = libxml.parseHtmlString(body);
37 | 	doc.find("//h2").forEach(function(sectionTitleEl){ // section
38 | 	    var sectionTitle = sectionTitleEl.text().trim();
39 | 	    var sectionId = makeAnchor(String(sectionTitleEl.attr('id') || sectionTitle).trim());
40 | 	    var sectionBodyEl = sectionTitleEl.nextElement();
41 | 	    var functions = [];
42 | 	    doc.find(sectionBodyEl.path()+"//dt[@class='hdlist1']").forEach(function(funcNameEl){
43 | 		var funcName = funcNameEl.text().trim();
44 | 		var funcBodyEl = funcNameEl.nextElement(); // dd
45 | 		var anchor = "_"+makeAnchor(sectionId+" "+funcName);
46 | 		functions.push({'module': sectionTitle, 'name': funcName, 'anchor': anchor, 'description': funcBodyEl.text().trim().replace(/[ \t\r\n]+/g,' '), 'description_html': String(funcBodyEl).replace(/&#13;/g,'')});
47 | 	    });
48 | 	    var sectionDescriptionEl = doc.get(sectionBodyEl.path());
49 | 	    if(sectionTitle!="NAME") {
50 | 		modules.push({'name': sectionTitle, 'anchor': sectionId, 'description': sectionDescriptionEl.text().trim().replace(/[ \t\r\n]+/g,' '), 'description_html': String(sectionDescriptionEl).replace(/&#13;/g,''), 'functions': functions});
51 | 	    }
52 | 	});
53 | 	fs.writeFile('api.json', JSON.stringify(modules));
54 | 	
55 | 	// Create api.html
56 | 	var doc = libxml.parseHtmlString(body);
57 | 	doc.find("//h2").forEach(function(sectionTitleEl){ // section
58 | 	    var sectionTitle = sectionTitleEl.text().trim();
59 | 	    var sectionId = makeAnchor(String(sectionTitleEl.attr('id') || sectionTitle).trim());
60 | 	    sectionTitleEl.attr({"id": sectionId});
61 | 	    sectionTitleEl.addChild(new libxml.Element(doc, "a", {'name': sectionId}, ' '));
62 | 	    var sectionBodyEl = sectionTitleEl.nextElement();
63 | 	    doc.find(sectionBodyEl.path()+"//dt[@class='hdlist1']").forEach(function(funcNameEl){
64 | 		var funcName = funcNameEl.text().trim();
65 | 		var anchor = "_"+makeAnchor(sectionId+" "+funcName);
66 | 		funcNameEl.attr({"id": anchor});
67 | 		funcNameEl.addChild(new libxml.Element(doc, "a", {'name': anchor}, ' '));
68 | 	    });
69 | 	});
70 | 	doc.get("//head").childNodes().forEach(function(el) {
71 | 	    el.remove();
72 | 	});
73 | 	doc.get("//head").addChild(new libxml.Element(doc, "title", {}, "nodejs manual"));
74 | 	doc.get("//head").addChild(new libxml.Element(doc, "link", {'href': "/style.css", 'rel': "stylesheet", 'type': "text/css", 'charset': "utf-8"}));
75 | 
76 | 	fs.writeFile('api.html', String(doc));
77 |     });
78 | });
79 | request.close();
80 | 
81 | 
82 | 


--------------------------------------------------------------------------------
/examples/nodeman/import.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | var sys = require('sys');
 3 | var config = require('./config');
 4 | var mysql = require('../../lib/mysql');
 5 | 
 6 | /*
 7 | MySQL preparation
 8 | $ mysql -u root
 9 | CREATE DATABASE nodeman DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
10 | GRANT ALL ON nodeman.* TO nodeman@localhost IDENTIFIED BY "nodeman";
11 | */
12 | 
13 | var conn = new mysql.Connection(config.mysql.hostname, config.mysql.username, config.mysql.password, config.mysql.database, config.mysql.port);
14 | conn.connect();
15 | conn.query("CREATE TABLE IF NOT EXISTS functions(id INTEGER AUTO_INCREMENT, module_id INTEGER, name VARCHAR(254), anchor VARCHAR(254), description TEXT, description_html TEXT, PRIMARY KEY (id), FULLTEXT(name), FULLTEXT(description)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
16 | conn.query("TRUNCATE functions");
17 | conn.query("CREATE TABLE IF NOT EXISTS modules(id INTEGER AUTO_INCREMENT, anchor VARCHAR(254), name VARCHAR(254), description TEXT, description_html TEXT, PRIMARY KEY (id), FULLTEXT(name), FULLTEXT(description)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
18 | conn.query("TRUNCATE modules");
19 | 
20 | var json = '';
21 | process.stdio.addListener('data', function (data) { json += data; });
22 | process.stdio.addListener('close', function (data) {
23 |     var sections = JSON.parse(json);
24 |     sections.forEach(function(section) {
25 | 	conn.query(["INSERT INTO modules(name, anchor, description, description_html) VALUES(?,?,?,?)", section.name, section.anchor, section.description, section.description_html], function(result) {
26 | 	    module_id = conn.insert_id;
27 | 	    sys.puts(section.name);
28 | 	    section.functions.forEach(function(func) {
29 | 		sys.puts("  "+func.name);
30 | 		conn.query(["INSERT INTO functions(name, anchor, module_id, description, description_html) VALUES(?,?,?,?,?)", func.name, func.anchor, module_id, func.description, func.description_html]);
31 | 	    });
32 | 	    if(sections[sections.length-1]==section) {
33 | 		conn.close();
34 | 	    }
35 | 	});
36 |     });
37 | });
38 | process.stdio.open();
39 | 


--------------------------------------------------------------------------------
/examples/nodeman/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
  2 |     "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
  3 | <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
  4 | <head>
  5 | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  6 | <title>nodejs api search</title>
  7 | <link rel="stylesheet" href="http://yui.yahooapis.com/2.7.0/build/reset-fonts-grids/reset-fonts-grids.css" type="text/css"> 
  8 | <style>
  9 | /* Layout */
 10 | html, body { height: 100%; overflow: hidden; }
 11 | #doc3 { margin: 0 !important; }
 12 | #hd { height: 50px; }
 13 | #ft { display: none; }
 14 | 
 15 | /* Global style */
 16 | * { font-family: "Lucida Grande", 'Lucida Sans', 'Lucida Sans', Lucida, sans-serif; }
 17 | a { text-decoration: none; }
 18 | 
 19 | /* Styles */
 20 | #hd { background: #eee; color: #fff; }
 21 | #hd h1 { line-height: 50px; margin: 0 8px; font-size: 197%; color: #000; }
 22 | #bd { border-top: 1px solid #888; }
 23 | 
 24 | /* Navigator styles */
 25 | .navigator { border-right: 1px solid #888; }
 26 | .keyword-box { background: #ddd; }
 27 | #keyword { font-family: Helvetica, Arial, Verdana, sans-serif; }
 28 | #keyword { font-size: 123.1%;/*16px*/ height: 24px; background: #fff; border: 1px solid #888; margin: 4px; padding: 0 4px; width: 282px; }
 29 | 
 30 | #list { overflow: auto; height: 200px; }
 31 | #list a { color: #000; }
 32 | #list .label { font-size: 85%; font-weight: bold; background: #ddd; padding: 2px 4px; }
 33 | #list .section { margin: 0 0 4px 0; }
 34 | #list .item { overflow: hidden; display: block; padding: 4px 8px; }
 35 | #list .item:hover { background: #D8F2F4; }
 36 | #list .item .title { }
 37 | #list .item .subtitle { color: #888; font-size: 77%; margin: 2px 0 0 0; }
 38 | #list .item .arguments { color: #888; font-style: italic; }
 39 | 
 40 | #content-wrap { margin: 0 0 0 -12px; }
 41 | #content { border: 0; width: 100%; }
 42 | 
 43 | #footer { position: absolute; bottom: 0px; width: 100%; text-align: center; color: #888; line-height: 31px; border-top: 1px solid #aaa; background: #fff; }
 44 | #footer a  { color: #666; }
 45 | </style>
 46 | <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
 47 | <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.7.2/jquery-ui.min.js"></script>
 48 | <script>
 49 | // create inner link
 50 | var create_link = function(id, inner) {
 51 |   return '<a href="#" onclick="select_item(&quot;'+h(id)+'&quot;);return false;" class="item">'+inner+'</a>';
 52 | }
 53 | 
 54 | // Observe keyword field
 55 | var searched_keyword = '';
 56 | var search_state = 'DONE';
 57 | setInterval(function() {
 58 |   var keyword = $('#keyword').val();
 59 |   if(keyword) {
 60 |     if(keyword!=searched_keyword && search_state!='PROGRESS') {
 61 |       search_state = 'PROGRESS';
 62 |       $.getJSON("/json/search.json", {'query': keyword}, function(json) {
 63 |         ['modules', 'functions', 'search'].forEach(function(sec) {
 64 |           html = json[sec].map(function(item) {
 65 |             var name = h(item.name || '').replace(/(\(.*)$/g,"<span class=\"arguments\">$1</span>");
 66 |             var inner = '<div class="title">'+name+'</div><div class="subtitle">'+h(item.module_name || '')+'</div>';
 67 |             return create_link(item.anchor, inner);
 68 |           }).join("");
 69 |           $("#list ."+sec+"-section").html(html);
 70 |           searched_keyword = keyword;
 71 |           search_state = 'DONE';
 72 |         });
 73 |       });
 74 |     }
 75 |   }
 76 |   else {
 77 |     load_modules();
 78 |   }
 79 | }, 1000);
 80 | 
 81 | // 
 82 | var loaded_modules = false;
 83 | var load_modules = function() {
 84 |   var render = function() {
 85 |     $("#list .modules-section").html(loaded_modules);
 86 |     $("#list .functions-section").html('');
 87 |     $("#list .search-section").html('');
 88 |   }
 89 |   if(loaded_modules) {
 90 |     render();
 91 |   }
 92 |   else {
 93 |     $.getJSON("/json/modules.json", {}, function(json) {
 94 |       html = json['modules'].map(function(item) {
 95 |         var name = h(item.name || '').replace(/(\(.*)$/g,"<span class=\"arguments\">$1</span>");
 96 |         var inner = '<div class="title">'+name+'</div><div class="subtitle">'+h(item.module_name || '')+'</div>';
 97 |         return create_link(item.anchor, inner);
 98 |       }).join("");
 99 |       loaded_modules = html;
100 |       render();
101 |     });
102 |   }
103 | }
104 | 
105 | // Select item
106 | var select_item = function(id) {
107 |   content_window.location.hash = id;
108 |   setTimeout(function() {
109 |     $('body').scrollTop(0);
110 |   }, 250);
111 |   $("#keyword").focus();
112 | }
113 | 
114 | // Layout
115 | var layout = function() {
116 |   $('#list').height($(window).height()-$('#list').offset().top-32);
117 |   setTimeout(function() {
118 |     $('#content').height($(window).height()-$('#content').offset().top-32
119 | );
120 |   }, 250);
121 | }
122 | $(window).resize(layout);
123 | 
124 | // Utils
125 | var h = (function(){
126 |   var map = {"<":"&lt;", ">":"&gt;", "&":"&amp;", "'":"&#39;", "\"":"&quot;", " ":"&nbsp;"};
127 |   var replaceStr = function(s){ return map[s]; };
128 |     return function(str) { return (str+"").replace(/<|>|&|\'|\"|\s/g, replaceStr); };
129 | })();
130 | 
131 | // Start up
132 | var content_window;
133 | $(document).ready(function() {
134 |   content_window = $('#content')[0].contentWindow;
135 |   layout();
136 |   $("#keyword").focus();
137 | });
138 | </script>
139 | </head>
140 | <body>
141 |  <div id="doc3" class="yui-t3">
142 |   <div id="hd" role="banner">
143 |    <h1>nodejs api search</h1>
144 |   </div>
145 |   <div id="bd" role="main">
146 |    <div id="yui-main"><div class="yui-b"><div class="yui-g" id="content-wrap"> 
147 |     <div id="content-header">
148 |     </div>
149 |     <iframe src="api.html" id="content"></iframe>
150 |    </div></div></div><!-- /.yui-g .yui-b #yui-main-->
151 |    <div class="yui-b navigator">
152 |     <div class="keyword-box">
153 |      <input id="keyword"/>
154 |     </div>
155 |     <div id="list">
156 |      <div class="section">
157 |       <div class="modules-title label">Modules</div>
158 |       <div class="modules-section"></div>
159 |      </div>
160 |      <div class="section">
161 |       <div class="function-title label">Functions</div>
162 |       <div class="functions-section"></div>
163 |      </div>
164 |      <div class="section">
165 |       <div class="search-title label">Fulltext search</div>
166 |       <div class="search-section"></div>
167 |      </div>
168 |     </div><!-- /.list -->
169 |    </div><!-- /.yui-b -->
170 |   </div><!-- /#bd -->
171 |  </div><!-- /#doc3 -->
172 |  <div id="footer">
173 |   Powered by <a href="http://nodejs.org/">node.js</a> + <a href="http://github.com/masuidrive/node-mysql">node-mysql</a> + <a href="http://twitter.com/masuidrive_en">@masuidrive_en</a>.
174 |  </div>
175 | </body>
176 | </html>
177 | 
178 | 


--------------------------------------------------------------------------------
/examples/nodeman/server.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | var fs = require("fs");
  3 | var sys = require('sys');
  4 | var http = require('http');
  5 | var url = require('url');
  6 | var querystring = require('querystring');
  7 | var config = require('./config');
  8 | var mysql = require('../../lib/mysql');
  9 | 
 10 | var conn = new mysql.Connection(config.mysql.hostname, config.mysql.username, config.mysql.password, config.mysql.database, config.mysql.port);
 11 | conn.connect();
 12 | conn.addListener('close', function(){
 13 |     sys.puts("reconnect after 10sec");
 14 |     setTimeout(function() {
 15 | 	sys.puts("reconnect");
 16 | 	conn.connect();
 17 |     }, 10*1000);
 18 | });
 19 | 
 20 | var truncate = function(str, len) {
 21 |     if(str.length<=len+3) return str;
 22 |     return str.substring(0, len-3)+"...";
 23 | }
 24 | 
 25 | var moduleListJson = function(query, callback) {
 26 |     var result = {};
 27 |     conn.query("SELECT name, anchor, id FROM modules ORDER BY id", function(res) {
 28 | 	result['modules'] = res.records.map(function(r) { return res.toHash(r); });
 29 | 	callback(result);
 30 |     },
 31 |     function(error) { callback({'error': error}); });
 32 | }
 33 | 
 34 | var moduleJson = function(params, callback) {
 35 |     var result = {};
 36 |     conn.query(["SELECT name, anchor, description_html FROM modules WHERE id=?", params.id], function(res) {
 37 | 	if(res.records.length>0) {
 38 | 	    result['name'] = res.records[0][0];
 39 | 	    result['anchor'] = res.records[0][1];
 40 | 	    result['description'] = res.records[0][2];
 41 | 	}
 42 | 	conn.query(["SELECT id, name, anchor, description FROM functions WHERE module_id=?", parmas.id], function(res) {
 43 | 	    result.functions = res.records.map(function(row) {
 44 | 		return({'id': row[0], 'name': row[1], 'anchor': row[2], 'description': truncate(row[3], 100) });
 45 | 	    });
 46 | 	    callback(result);
 47 | 	},
 48 | 	function(error) { callback({'error': error}); });
 49 |     },
 50 |     function(error) { callback({'error': error}); });
 51 | }
 52 | 
 53 | var functionJson = function(params, callback) {
 54 |     var result = {};
 55 |     conn.query(["SELECT functions.name as name, functions.anchor as anchor, functions.description_html as description, functions.module_id as module_id, modules.name as module_name FROM functions INNER JOIN modules ON functions.module_id=modules.id WHERE functions.id=? LIMIT 1", paramsid], function(res) {
 56 | 	if(res.records.length>0) {
 57 | 	    result = res.toHash(res.records[0]);
 58 | 	}
 59 | 	callback(result);
 60 |     },
 61 |     function(error) { callback({'error': error}); });
 62 | }
 63 | 
 64 | var searchJson = function(params, callback) {
 65 |     var result = {'modules':[], 'functions': [], 'search':[]};
 66 |     if(!params.query) return callback(result);
 67 |     var q = String(params.query).trim();
 68 |     var like_q = '%'+q.replace(/%/g,'%%')+'%';
 69 |     conn.query(["SELECT name, anchor, id FROM modules WHERE name LIKE ?", like_q], function(res) {
 70 | 	result.modules = res.records.map(function(r){ return res.toHash(r); });
 71 |     },
 72 |     function(error) { callback({'error': error}); });
 73 |     
 74 |     conn.query(["SELECT functions.id as id, functions.name as name, functions.anchor as anchor, modules.name as module_name FROM functions INNER JOIN modules ON functions.module_id=modules.id WHERE functions.name LIKE ?", like_q], function(res) {
 75 | 	result.functions = res.records.map(function(r){ return res.toHash(r); });
 76 |     },
 77 |     function(error) { callback({'error': error}); });
 78 |     
 79 |     conn.query(["SELECT functions.id as id, functions.name as name, functions.anchor as anchor, modules.name as module_name FROM functions INNER JOIN modules ON functions.module_id=modules.id WHERE MATCH(functions.description) AGAINST(? IN BOOLEAN MODE) LIMIT 10", q+"*"], function(res) {
 80 | 	result.search = res.records.map(function(r){ return res.toHash(r); }).filter(function(item) {
 81 | 	    for(var i=0; i<result.functions.length; ++i) {
 82 | 		if(item.id==result.functions[i].id) return false;
 83 | 	    };
 84 | 	    return true;
 85 | 	});
 86 | 	callback(result);
 87 |     },
 88 |     function(error) { callback({'error': error}); });
 89 | }
 90 | 
 91 | var staticPage = function(filename, mimeType) {
 92 |     var html = fs.readFileSync(__dirname+"/"+filename);
 93 |     return function(params, callback) {
 94 | 	callback(html, mimeType);
 95 |     };
 96 | }
 97 | 
 98 | var routes = {
 99 |     '/': staticPage('index.html', 'text/html'),
100 |     '/style.css': staticPage('style.css', 'text/css'),
101 |     '/api.html': staticPage('api.html', 'text/html'),
102 |     '/json/modules.json': moduleListJson,
103 |     '/json/module.json': moduleJson,
104 |     '/json/function.json': functionJson,
105 |     '/json/search.json': searchJson
106 | };
107 | 
108 | http.createServer(function (req, res) {
109 |     var loc = url.parse(req.url);
110 |     if(routes[loc.pathname]) {
111 | 	sys.log(loc.pathname);
112 | 	routes[loc.pathname](querystring.parse(loc.query), function(result, mimeType) {
113 | 	    if(typeof(result)=="string") {
114 | 		res.writeHead(200, {'Content-Type': (mimeType || 'text/html; charset=utf-8')});
115 | 		res.write(result);
116 | 	    }
117 | 	    else {
118 | 		res.writeHead(200, {'Content-Type': 'text/plain'});
119 | 		res.write(JSON.stringify(result));
120 | 	    }
121 | 	    res.close();
122 | 	});
123 |     }
124 |     else {
125 | 	res.writeHead(404, {'Content-Type': 'text/plain'});
126 | 	res.write('Not found');
127 | 	res.close();
128 |     }
129 | }).listen(8000);
130 | 
131 | sys.puts('Server running at http://127.0.0.1:8000/');
132 | 


--------------------------------------------------------------------------------
/examples/nodeman/style.css:
--------------------------------------------------------------------------------
1 | a { color: #DD6391; }
2 | h3 { border-bottom: 1px solid #888; font-size: 123.1%; font-weight: bold; padding: 8px 0 2px 0; margin: 0 0 4px 0; }
3 | pre { border-left: 1px solid #aaa; padding: 2px 6px; margin: 8px 2px; }
4 | .sectionbody { margin: 0 0 12px 0; }
5 | table, th, td { border: 1px solid #aaa; }
6 | th, td { padding: 2px; }
7 | th { font-weight: bold; }
8 | p { margin: 4px 0; }
9 | 


--------------------------------------------------------------------------------
/examples/simple1.js:
--------------------------------------------------------------------------------
 1 | var sys = require('sys');
 2 | var mysql = require('../lib/mysql');
 3 | 
 4 | /*
 5 | > mysql -u root
 6 | CREATE DATABASE nodejs_mysql  DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
 7 | GRANT ALL ON nodejs_mysql.* TO nodejs_mysql@localhost IDENTIFIED BY "nodejs_mysql";
 8 | */
 9 | var conn = new mysql.Connection('localhost','nodejs_mysql', 'nodejs_mysql', 'nodejs_mysql');
10 | conn.connect();
11 | conn.query("CREATE TEMPORARY TABLE test1(intval INTEGER, strval TEXT, timestampval TIMESTAMP, boolval BOOLEAN);");
12 | conn.query("INSERT INTO test1 VALUES(1,'a',now(),true);");
13 | conn.query("SELECT * FROM test1;",
14 |     function(result) {
15 |         for(var i=0; i<result.records.length; ++i) {
16 |             sys.puts("Result: "+sys.inspect(result.toHash(result.records[i])));
17 |         };
18 |         conn.close();
19 |     },
20 |     function(error) {
21 | 	sys.puts("Error: "+sys.inspect(error));
22 |         conn.close();
23 |     });
24 | 


--------------------------------------------------------------------------------
/examples/speedtest.js:
--------------------------------------------------------------------------------
 1 | var
 2 |   sys   = require("sys"),
 3 |   mysql = require('../lib/mysql');
 4 | 
 5 | var puts = sys.puts;
 6 | var inspect = sys.inspect;
 7 | 
 8 | function readTest(db) {
 9 |   var t0 = new Date;
10 |   var rows = 0;
11 |   conn.query("SELECT * FROM t1;", function(result) {
12 |       var d = ((new Date)-t0)/1000;
13 |       puts("**** " + result.records.length + " rows in " + d + "s (" + (result.records.length/d) + "/s)");
14 |       
15 |       conn.close();
16 |   });
17 | }
18 | 
19 | function writeTest(db, i, callback) {
20 |   conn.query("INSERT INTO t1 VALUES (1);", function (row) {
21 |     if (!--i) {
22 |       // end of results
23 |       var dt = ((new Date)-t0)/1000;
24 |       puts("**** " + count + " insertions in " + dt + "s (" + (count/dt) + "/s)");
25 | 
26 |       if (callback) callback(db);
27 |     }
28 |     else {
29 |       writeTest(db, i--, callback);
30 |     }
31 |   });
32 | }
33 | 
34 | var count = 100000;
35 | var t0;
36 | 
37 | /*
38 | > mysql -u root
39 | CREATE DATABASE nodejs_mysql  DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
40 | GRANT ALL ON nodejs_mysql.* TO nodejs_mysql@localhost IDENTIFIED BY "nodejs_mysql";
41 | */
42 | var conn = new mysql.Connection('localhost','nodejs_mysql', 'nodejs_mysql', 'nodejs_mysql');
43 | conn.connect();
44 | 
45 | conn.query("DROP TABLE t1;");
46 | 
47 | conn.query("CREATE TABLE t1 (alpha INTEGER) TYPE=MEMORY;", function () {
48 |   puts("create table callback" + inspect(arguments));
49 |   t0 = new Date;
50 |   writeTest(conn, count, readTest);
51 | });
52 | 
53 | 


--------------------------------------------------------------------------------
/lib/mysql.js:
--------------------------------------------------------------------------------
  1 | /*
  2 | node-mysql
  3 | 
  4 | node-mysql is pure Javascript MySQL network driver for [node.js](http://nodejs.org/)
  5 | */
  6 | var sys = require('sys');
  7 | var events = require('events');
  8 | var result = require('./mysql/result');
  9 | var types = require('./mysql/types');
 10 | var utils = require('./mysql/utils');
 11 | var errors = require('./mysql/errors');
 12 | var Promise = require('./mysql/node-promise').Promise;
 13 | var Protocol = require('./mysql/protocol').Protocol;
 14 | var constants = require('./mysql/constants')
 15 | exports.constants = constants;
 16 | 
 17 | exports.Time = types.Time;
 18 | exports.quote = types.quote;
 19 | exports.constants = constants;
 20 | 
 21 | 
 22 | var Connection = function(hostname, username, password, dbname, port) {
 23 |     events.EventEmitter.call(this);
 24 |     this.protocol = undefined;
 25 |     this.active = false;
 26 |     this.connect_parameter = Array.prototype.slice.call(arguments);
 27 |     this.last_error = undefined;
 28 |     this.sqlstate = undefined;
 29 |     this._timeout = undefined;
 30 |     this.defaultErrback = function(error) {
 31 | 	sys.puts("MySQL error: "+error);
 32 |     }
 33 | }
 34 | sys.inherits(Connection, events.EventEmitter);
 35 | exports.Connection = Connection;
 36 | 
 37 | Connection.prototype.connect = function(callback, errback) {
 38 |     this.protocol = new Protocol(this.connect_parameter[0], this.connect_parameter[4]);
 39 |     if(this._timeout) this.protocol.timeout(this._timeout);
 40 |     this.protocol.addListener('connect', utils.scope(this, function() {	
 41 | 	this.active = false;
 42 | 	this.emit('connect');
 43 | 	this.protocol.authenticate(this.connect_parameter[1],
 44 | 				   this.connect_parameter[2],
 45 | 				   this.connect_parameter[3],
 46 | 				   (this.local_infile ? constants.client.LOCAL_FILES : 0),
 47 | 				   'utf8_general_ci'
 48 | 				  )
 49 | 	    .addCallback(callback)
 50 | 	    .addErrback(errback || this.defaultErrback);
 51 |     }));
 52 |     this.protocol.addListener('close', utils.scope(this, function() {	
 53 | 	this.active = false;
 54 | 	this.emit('close');
 55 |     }));
 56 |     this.protocol.addListener('authorized', utils.scope(this, function() {	
 57 | 	this.active = true;
 58 | 	this.emit('authorized');
 59 |     }));
 60 |     this.protocol.addListener('authorize error', utils.scope(this, function() {
 61 | 	this.active = false;
 62 | 	this.emit('authorize error');
 63 |     }));
 64 | }
 65 | 
 66 | Connection.prototype.close = function() {
 67 |     this.protocol.close();
 68 | }
 69 | 
 70 | Connection.prototype.timeout = function(msec) {
 71 |     if(msec) {
 72 | 	this._timeout = msec;
 73 | 	if(this.protocol) this.protocol.timeout(this._timeout);
 74 |     }
 75 |     return this._timeout;
 76 | }
 77 | 
 78 | // Set autocommit mode
 79 | Connection.prototype.autocommit = function(flag, callback, errback) {
 80 |     this.query("set autocommit="+(flag ? "1" : "0"), callback, (errback || this.defaultErrback));
 81 | }
 82 | 
 83 | Connection.prototype.query = function(sql, callback, errback) {
 84 |     var sql = this.extract_placeholder(sql);
 85 |     if(sql.constructor==errors.ClientError.prototype.constructor) {
 86 | 	(errback || this.defaultErrback)(sql);
 87 | 	return;
 88 |     }
 89 |     this.protocol.query_command(sql)
 90 | 	.addCallback(utils.scope(this, function(nfields) {
 91 | 	    if(nfields) {
 92 | 		this.protocol.retr_fields(nfields)
 93 | 		    .addCallback(utils.scope(this, function(fields) {
 94 | 			this.fields = fields;
 95 | 			this.get_result()
 96 | 			    .addCallback(utils.scope(this, function(rows) {
 97 | 				this.server_status = this.protocol.server_status;
 98 | 				try {
 99 | 				    if(callback) callback(rows);
100 | 				}
101 | 				catch(error) {
102 | 				    (errback || this.defaultErrback)(error);
103 | 				}
104 | 			    }))
105 | 			    .addErrback(errback || this.defaultErrback);
106 | 		    }))
107 | 		    .addErrback(errback || this.defaultErrback);
108 | 	    }
109 | 	    else {
110 | 		var result = {};
111 | 		result.affected_rows = this.affected_rows = this.protocol.affected_rows;
112 | 		result.insert_id = this.insert_id = this.protocol.insert_id;
113 | 		result.server_status = this.server_status = this.protocol.server_status;
114 | 		result.warning_count = this.warning_count = this.protocol.warning_count;
115 | 		result.info = this.info = this.protocol.message;
116 | 		try {
117 | 		    if(callback) callback(result);
118 | 		}
119 | 		catch(error) {
120 | 		    (errback || this.defaultErrback)(error);
121 | 		}
122 | 	    }
123 | 	}))
124 | 	.addErrback(errback || this.defaultErrback);
125 | }
126 | 
127 | Connection.prototype.extract_placeholder = function(sql) {
128 |     if(typeof(sql)=='string') return sql;
129 |     
130 |     var format = sql[0];
131 |     var bind = sql.slice(1).map(function(v) {
132 | 	return types.convertToSQLString(v);
133 |     });
134 |     if(format.match(/\?/g).length!=bind.length) {
135 | 	return new errors.ClientError('parameter count mismatch');
136 |     }
137 |     return format.replace(/\?/g, function() {
138 | 	return bind.shift();
139 |     });
140 | }
141 | 
142 | Connection.prototype.set_server_option = function(opt) {
143 |     return this.protocol.set_option_command(opt);
144 | }
145 | 
146 | Connection.prototype.get_result = function(fields) {
147 |     var res = new result.Result(this.fields.map(function(field) {
148 | 	return(new Field(field));
149 |     }), this.protocol);
150 |     return res.fetch_all();
151 | }
152 | 
153 | Connection.prototype.has_more_results = function() {
154 |     return !!(this.protocol.server_status & constants.server.MORE_RESULTS_EXISTS);
155 | }
156 | 
157 | Connection.prototype.next_result = function(callback, errback) {
158 |     if(!this.has_more_results()) {
159 | 	process.nextTick(new Error("ClientError", "Don't have more results"));
160 | 	return;
161 |     }
162 |     this.protocol.get_result()
163 | 	.addCallback(utils.scope(this, function(nfields) {
164 | 	    this.protocol.retr_fields(nfields)
165 | 		.addCallback(utils.scope(this, function(fields) {
166 | 		    this.fields = fields;
167 | 		    this.result_exist = true;
168 | 		    this.get_result()
169 | 			.addCallback(utils.scope(this, function(results) {
170 | 			    try {
171 | 				if(callback) callback(results);
172 | 			    }
173 | 			    catch(error) {
174 | 				(errback || this.defaultErrback)(error);
175 | 			    }
176 | 			}))
177 | 			.addErrback(errback || this.defaultErrback);
178 | 		}))
179 | 		.addErrback(errback || this.defaultErrback);
180 | 	}))
181 | 	.addErrback(errback || this.defaultErrback);
182 | }
183 | 
184 | Connection.prototype.prepare = function(str, callback, errback) {
185 |     var stmt = new Stmt(this.protocol, this.charset);
186 |     return stmt.prepare(str, callback, (errback || this.defaultErrback));
187 | };
188 | 
189 | 
190 | var Stmt = function(protocol, charset) {
191 |     this.protocol = protocol;
192 |     this.charset = charset;
193 |     this.statement_id = undefined;
194 |     this.affected_rows = this.insert_id = this.server_status = this.warning_count = 0;
195 |     this.sqlstate = "00000";
196 |     this.param_count = undefined;
197 | }
198 | 
199 | Stmt.prototype.close = function() {
200 |     this.protocol.stmt_close_command(this.statement_id);
201 |     this.statement_id = undefined;
202 |     this.param_count = undefined;
203 | }
204 | 
205 | Stmt.prototype.prepare = function(query, callback, errback) {
206 |     this.close();
207 |     this.protocol.stmt_prepare_command(query)
208 |         .addCallback(utils.scope(this, function(statement_id, param_count, field_packets) {
209 | 	    this.statement_id = statement_id;
210 |             this.sqlstate = "00000";
211 | 	    this.param_count = param_count;
212 | 	    this.fields = field_packets.map(function(field_packet) {
213 | 		return new Field(field_packet);
214 | 	    });
215 | 	    try {
216 | 		if(callback) callback(this);
217 | 	    }
218 | 	    catch(error) {
219 | 		(errback || this.defaultErrback)(error);
220 | 	    }
221 |         }))
222 |         .addErrback(errback || this.defaultErrback);
223 | }
224 | 
225 | Stmt.prototype.execute = function(args, callback, errback) {
226 |     if(typeof(this.param_count)=='undefined') {
227 | 	errback(new errors.ClientError("not prepared"));
228 | 	return;
229 |     }
230 |     if(this.param_count!=args.length) {
231 | 	errback(new errors.ClientError("parameter count mismatch"));
232 | 	return;
233 |     }
234 |     this.sqlstate = "00000";
235 |     this.protocol.stmt_execute_command(this.statement_id, args)
236 |         .addCallback(utils.scope(this, function(nfields) {
237 |             if(typeof(nfields)!='undefined') {
238 | 		this.protocol.retr_fields(nfields)
239 | 		    .addCallback(utils.scope(this, function(fields) {
240 | 			this.fields = fields;
241 | 			this.result = new result.StatementResult(this.fields, this.protocol);
242 | 			this.protocol.stmt_retr_all_records(fields, this.charset)
243 | 			    .addCallback(utils.scope(this, function(records) {
244 | 				this.result.records = records;
245 | 				try {
246 | 				    callback(this.result);
247 | 				}
248 | 				catch(error) {
249 | 				    (errback || this.defaultErrback)(error);
250 | 				}
251 | 			    }))
252 | 			    .addErrback(errback || this.defaultErrback);
253 | 		    }))
254 | 		    .addErrback(errback || this.defaultErrback);
255 | 	    }
256 | 	    else {
257 | 		this.affected_rows = this.protocol.affected_rows;
258 | 		this.insert_id = this.protocol.insert_id;
259 | 		this.server_status = this.protocol.server_status;
260 | 		this.warning_count = this.protocol.warning_count;
261 | 		this.info = this.protocol.message;
262 | 		try {
263 | 		    callback();
264 | 		}
265 | 		catch(error) {
266 | 		    (errback || this.defaultErrback)(error);
267 | 		}
268 | 	    }
269 | 	}))
270 | 	.addErrback(errback || this.defaultErrback);
271 | }
272 | 
273 | 
274 | var Field = function(packet) {
275 |     this.db = packet.db;
276 |     this.table = packet.table;
277 |     this.org_table = packet.org_table;
278 |     this.name = packet.name;
279 |     this.org_name = packet.org_name;
280 |     this.charsetnr = packet.charsetnr;
281 |     this.length = packet.length;
282 |     this.type = packet.type;
283 |     this.flags = packet.flags;
284 |     this.decimals = packet.decimals;
285 |     this.defaultVal = packet.defaultVal;
286 | }
287 | exports.Field = Field;
288 | 
289 | Field.prototype.is_num = function() {
290 |     return [constants.field.TYPE_DECIMAL, constants.field.TYPE_TINY, constants.field.TYPE_SHORT, constants.field.TYPE_LONG, constants.field.TYPE_FLOAT, constants.field.TYPE_DOUBLE, constants.field.TYPE_LONGLONG, constants.field.TYPE_INT24].indexOf(this.type.id) >= 0;
291 | }
292 | 
293 | Field.prototype.is_not_null = function() {
294 |     return !!(this.flags & constants.field.NOT_NULL_FLAG);
295 | }
296 | 
297 | Field.prototype.is_pri_key = function() {
298 |     return !!(this.flags & constants.field.PRI_KEY_FLAG);
299 | }
300 | 
301 | 
302 | /*
303 | node-mysql
304 | A node.js interface for MySQL
305 | 
306 | Author: masuidrive <masui@masuidrive.jp>
307 | License: MIT License
308 | Copyright (c) Yuichiro MASUI
309 | 
310 | # Original:
311 | # http://github.com/tmtm/ruby-mysql
312 | # Copyright (C) 2009-2010 TOMITA Masahiro
313 | # mailto:tommy@tmtm.org
314 | # License: Ruby's
315 | */
316 | 


--------------------------------------------------------------------------------
/lib/mysql/auth.js:
--------------------------------------------------------------------------------
 1 | var sha1;
 2 | try {
 3 |     var crypto = require('crypto');
 4 |     sha1 = function(message) {
 5 | 	return (new crypto.Hash).init("sha1").update(message).digest();
 6 |     }
 7 | }
 8 | catch(e) {
 9 |     var SHA1 = require('./sha1').SHA1;
10 |     var i32tostr = function(i32) {
11 | 	var ret = '';
12 | 	for (var i=0; i<4; ++i) {
13 | 	    v = i32 & 0xff;
14 | 	    i32 >>>= 8;
15 | 	    ret = String.fromCharCode(v) + ret;
16 | 	}
17 | 	return ret;
18 |     };
19 |     
20 |     sha1 = function(message) {
21 | 	var digest = new SHA1(message).digest();
22 | 	var ret = "";
23 | 	for(var i=0; i<digest.length; ++i) {
24 | 	    ret += i32tostr(digest[i]);
25 | 	}
26 | 	return ret;
27 |     }
28 | }
29 | 
30 | exports.encrypt_password = function(plain, scramble) {
31 |     var stage1 = sha1(plain);
32 |     var stage2 = sha1(scramble+sha1(stage1));
33 |     var result = "";
34 |     for(var i=0; i<stage1.length; ++i) {
35 | 	result += String.fromCharCode(stage1.charCodeAt(i) ^ stage2.charCodeAt(i));
36 |     }
37 |     return(result);
38 | }
39 | 
40 | /*
41 | node-mysql
42 | A node.js interface for MySQL
43 | http://github.com/masuidrive/node-mysql
44 | 
45 | Copyright (c) Yuichiro MASUI <masui@masuidrive.jp>
46 | License: MIT License
47 | */
48 | 


--------------------------------------------------------------------------------
/lib/mysql/charset.js:
--------------------------------------------------------------------------------
  1 | var sys=require('sys');
  2 | exports.Charset = function(number, name, csname) {
  3 |     this.number = number;
  4 |     this.name = name;
  5 |     this.csname = csname;
  6 |     if(this.name=='utf8') {
  7 | 	this.convertToBytes = convertUTF8ToBytes;
  8 | 	this.convertFromBytes = convertUTF8FromBytes;
  9 |     }
 10 | }
 11 | 
 12 | exports.Charset.by_number = function(n) {
 13 |   for(var i=0; i<charset.length; ++i) {
 14 |       if(n==charset[i][0])
 15 | 	  return(new exports.Charset(charset[i][0], charset[i][1], charset[i][2]));
 16 |   }
 17 |   return undefined;
 18 | }
 19 | 
 20 | exports.Charset.by_name = function(n) {
 21 |   for(var i=0; i<charset.length; ++i) {
 22 |       if(n==charset[i][2])
 23 | 	  return(new exports.Charset(charset[i][0], charset[i][1], charset[i][2]));
 24 |   }
 25 |   return undefined;
 26 | }
 27 | 
 28 | exports.Charset.prototype.convertToBytes = function(str) {
 29 |     return str;
 30 | }
 31 | 
 32 | exports.Charset.prototype.convertFromBytes = function(bytes) {
 33 |     return bytes;
 34 | }
 35 | 
 36 | // "あい" => "\xE3\x81\x82\xE3\x81\x84"  // UTF-8
 37 | var convertUTF8ToBytes = function(str) {
 38 |     if(typeof(str)=='undefined') return undefined;
 39 |     if(typeof(str)=='undefined') return undefined;
 40 |     
 41 |     var surrogate_1st = 0;
 42 |     var unicode_codes = [];
 43 |     for (var i = 0; i < str.length; ++i) {
 44 | 	var utf16_code = str.charCodeAt(i);
 45 | 	if (surrogate_1st != 0) {
 46 | 	    if (utf16_code >= 0xdc00 && utf16_code <= 0xdfff) {
 47 | 		var surrogate_2nd = utf16_code;
 48 | 		var unicode_code = (surrogate_1st - 0xd800) * (1 << 10) + (1 << 16) +
 49 |                     (surrogate_2nd - 0xdc00);
 50 | 		unicode_codes.push(unicode_code);
 51 | 	    }
 52 | 	    surrogate_1st = 0;
 53 | 	}
 54 | 	else if (utf16_code >= 0xd800 && utf16_code <= 0xdbff) {
 55 | 	    surrogate_1st = utf16_code;
 56 | 	}
 57 | 	else {
 58 | 	    unicode_codes.push(utf16_code);
 59 | 	}
 60 |     }
 61 |     
 62 |     var utf8_bytes = "";
 63 |     var i, unicode_code;
 64 |     for(i=0; i<unicode_codes.length; ++i) {
 65 | 	unicode_code = unicode_codes[i];
 66 | 	if (unicode_code < 0x80) {  // 1-byte
 67 | 	    utf8_bytes += String.fromCharCode(unicode_code);
 68 | 	}
 69 | 	else if (unicode_code < (1 << 11)) {  // 2-byte
 70 | 	    utf8_bytes += String.fromCharCode((unicode_code >>> 6) | 0xC0);
 71 | 	    utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
 72 | 	}
 73 | 	else if (unicode_code < (1 << 16)) {  // 3-byte
 74 | 	    utf8_bytes += String.fromCharCode((unicode_code >>> 12) | 0xE0);
 75 | 	    utf8_bytes += String.fromCharCode(((unicode_code >> 6) & 0x3f) | 0x80);
 76 | 	    utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
 77 | 	}
 78 | 	else if (unicode_code < (1 << 21)) {  // 4-byte
 79 | 	    utf8_bytes += String.fromCharCode((unicode_code >>> 18) | 0xF0);
 80 | 	    utf8_bytes += String.fromCharCode(((unicode_code >> 12) & 0x3F) | 0x80);
 81 | 	    utf8_bytes += String.fromCharCode(((unicode_code >> 6) & 0x3F) | 0x80);
 82 | 	    utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
 83 | 	}
 84 |     }
 85 |     return utf8_bytes;
 86 | }
 87 | 
 88 | var convertUTF8FromBytes = function(str) {
 89 |     if(typeof(str)=='undefined') return undefined;
 90 | 
 91 |     var unicode_str = "";
 92 |     var unicode_code = 0;
 93 |     var num_followed = 0;
 94 |     var utf8_byte;
 95 |     for (var i = 0; i < str.length; ++i) {
 96 | 	utf8_byte = str.charCodeAt(i)
 97 | 	if (utf8_byte >= 0x100) {
 98 | 	    // Malformed utf8 byte ignored.
 99 | 	}
100 | 	else if ((utf8_byte & 0xc0) == 0x80) {
101 | 	    if (num_followed > 0) {
102 | 		unicode_code = (unicode_code << 6) | (utf8_byte & 0x3f);
103 | 		num_followed -= 1;
104 | 	    } else {
105 | 		// Malformed UTF-8 sequence ignored.
106 | 	    }
107 | 	}
108 | 	else {
109 | 	    if (num_followed == 0) {
110 | 		unicode_str += String.fromCharCode(unicode_code);
111 | 	    }
112 | 	    else {
113 | 		// Malformed UTF-8 sequence ignored.
114 | 	    }
115 | 	    if (utf8_byte < 0x80){  // 1-byte
116 | 		unicode_code = utf8_byte;
117 | 		num_followed = 0;
118 | 	    } else if ((utf8_byte & 0xe0) == 0xc0) {  // 2-byte
119 | 		unicode_code = utf8_byte & 0x1f;
120 | 		num_followed = 1;
121 | 	    } else if ((utf8_byte & 0xf0) == 0xe0) {  // 3-byte
122 | 		unicode_code = utf8_byte & 0x0f;
123 | 		num_followed = 2;
124 | 	    } else if ((utf8_byte & 0xf8) == 0xf0) {  // 4-byte
125 | 		unicode_code = utf8_byte & 0x07;
126 | 		num_followed = 3;
127 | 	    } else {
128 | 		// Malformed UTF-8 sequence ignored.
129 | 	    }
130 | 	}
131 |     }
132 |     if (num_followed == 0) {
133 | 	unicode_str += String.fromCharCode(unicode_code);
134 |     } else {
135 | 	// Malformed UTF-8 sequence ignored.
136 |     }
137 |     
138 |     return unicode_str.substring(1);
139 | 
140 | }
141 | 
142 | 
143 | // [[charset_number, charset_name, collation_name, default], ...]
144 | var charset = [
145 |                [  1, "big5",     "big5_chinese_ci",      true ],
146 |                [  2, "latin2",   "latin2_czech_cs",      false],
147 |                [  3, "dec8",     "dec8_swedish_ci",      true ],
148 |                [  4, "cp850",    "cp850_general_ci",     true ],
149 |                [  5, "latin1",   "latin1_german1_ci",    false],
150 |                [  6, "hp8",      "hp8_english_ci",       true ],
151 |                [  7, "koi8r",    "koi8r_general_ci",     true ],
152 |                [  8, "latin1",   "latin1_swedish_ci",    true ],
153 |                [  9, "latin2",   "latin2_general_ci",    true ],
154 |                [ 10, "swe7",     "swe7_swedish_ci",      true ],
155 |                [ 11, "ascii",    "ascii_general_ci",     true ],
156 |                [ 12, "ujis",     "ujis_japanese_ci",     true ],
157 |                [ 13, "sjis",     "sjis_japanese_ci",     true ],
158 |                [ 14, "cp1251",   "cp1251_bulgarian_ci",  false],
159 |                [ 15, "latin1",   "latin1_danish_ci",     false],
160 |                [ 16, "hebrew",   "hebrew_general_ci",    true ],
161 |                [ 17, "filename", "filename",             true ],
162 |                [ 18, "tis620",   "tis620_thai_ci",       true ],
163 |                [ 19, "euckr",    "euckr_korean_ci",      true ],
164 |                [ 20, "latin7",   "latin7_estonian_cs",   false],
165 |                [ 21, "latin2",   "latin2_hungarian_ci",  false],
166 |                [ 22, "koi8u",    "koi8u_general_ci",     true ],
167 |                [ 23, "cp1251",   "cp1251_ukrainian_ci",  false],
168 |                [ 24, "gb2312",   "gb2312_chinese_ci",    true ],
169 |                [ 25, "greek",    "greek_general_ci",     true ],
170 |                [ 26, "cp1250",   "cp1250_general_ci",    true ],
171 |                [ 27, "latin2",   "latin2_croatian_ci",   false],
172 |                [ 28, "gbk",      "gbk_chinese_ci",       true ],
173 |                [ 29, "cp1257",   "cp1257_lithuanian_ci", false],
174 |                [ 30, "latin5",   "latin5_turkish_ci",    true ],
175 |                [ 31, "latin1",   "latin1_german2_ci",    false],
176 |                [ 32, "armscii8", "armscii8_general_ci",  true ],
177 |                [ 33, "utf8",     "utf8_general_ci",      true ],
178 |                [ 34, "cp1250",   "cp1250_czech_cs",      false],
179 |                [ 35, "ucs2",     "ucs2_general_ci",      true ],
180 |                [ 36, "cp866",    "cp866_general_ci",     true ],
181 |                [ 37, "keybcs2",  "keybcs2_general_ci",   true ],
182 |                [ 38, "macce",    "macce_general_ci",     true ],
183 |                [ 39, "macroman", "macroman_general_ci",  true ],
184 |                [ 40, "cp852",    "cp852_general_ci",     true ],
185 |                [ 41, "latin7",   "latin7_general_ci",    true ],
186 |                [ 42, "latin7",   "latin7_general_cs",    false],
187 |                [ 43, "macce",    "macce_bin",            false],
188 |                [ 44, "cp1250",   "cp1250_croatian_ci",   false],
189 |                [ 47, "latin1",   "latin1_bin",           false],
190 |                [ 48, "latin1",   "latin1_general_ci",    false],
191 |                [ 49, "latin1",   "latin1_general_cs",    false],
192 |                [ 50, "cp1251",   "cp1251_bin",           false],
193 |                [ 51, "cp1251",   "cp1251_general_ci",    true ],
194 |                [ 52, "cp1251",   "cp1251_general_cs",    false],
195 |                [ 53, "macroman", "macroman_bin",         false],
196 |                [ 57, "cp1256",   "cp1256_general_ci",    true ],
197 |                [ 58, "cp1257",   "cp1257_bin",           false],
198 |                [ 59, "cp1257",   "cp1257_general_ci",    true ],
199 |                [ 63, "binary",   "binary",               true ],
200 |                [ 64, "armscii8", "armscii8_bin",         false],
201 |                [ 65, "ascii",    "ascii_bin",            false],
202 |                [ 66, "cp1250",   "cp1250_bin",           false],
203 |                [ 67, "cp1256",   "cp1256_bin",           false],
204 |                [ 68, "cp866",    "cp866_bin",            false],
205 |                [ 69, "dec8",     "dec8_bin",             false],
206 |                [ 70, "greek",    "greek_bin",            false],
207 |                [ 71, "hebrew",   "hebrew_bin",           false],
208 |                [ 72, "hp8",      "hp8_bin",              false],
209 |                [ 73, "keybcs2",  "keybcs2_bin",          false],
210 |                [ 74, "koi8r",    "koi8r_bin",            false],
211 |                [ 75, "koi8u",    "koi8u_bin",            false],
212 |                [ 77, "latin2",   "latin2_bin",           false],
213 |                [ 78, "latin5",   "latin5_bin",           false],
214 |                [ 79, "latin7",   "latin7_bin",           false],
215 |                [ 80, "cp850",    "cp850_bin",            false],
216 |                [ 81, "cp852",    "cp852_bin",            false],
217 |                [ 82, "swe7",     "swe7_bin",             false],
218 |                [ 83, "utf8",     "utf8_bin",             false],
219 |                [ 84, "big5",     "big5_bin",             false],
220 |                [ 85, "euckr",    "euckr_bin",            false],
221 |                [ 86, "gb2312",   "gb2312_bin",           false],
222 |                [ 87, "gbk",      "gbk_bin",              false],
223 |                [ 88, "sjis",     "sjis_bin",             false],
224 |                [ 89, "tis620",   "tis620_bin",           false],
225 |                [ 90, "ucs2",     "ucs2_bin",             false],
226 |                [ 91, "ujis",     "ujis_bin",             false],
227 |                [ 92, "geostd8",  "geostd8_general_ci",   true ],
228 |                [ 93, "geostd8",  "geostd8_bin",          false],
229 |                [ 94, "latin1",   "latin1_spanish_ci",    false],
230 |                [ 95, "cp932",    "cp932_japanese_ci"  ,  true ],
231 |                [ 96, "cp932",    "cp932_bin"          ,  false],
232 |                [ 97, "eucjpms",  "eucjpms_japanese_ci",  true ],
233 |                [ 98, "eucjpms",  "eucjpms_bin",          false],
234 |                [ 99, "cp1250",   "cp1250_polish_ci",     false],
235 |                [128, "ucs2",     "ucs2_unicode_ci",      false],
236 |                [129, "ucs2",     "ucs2_icelandic_ci",    false],
237 |                [130, "ucs2",     "ucs2_latvian_ci",      false],
238 |                [131, "ucs2",     "ucs2_romanian_ci",     false],
239 |                [132, "ucs2",     "ucs2_slovenian_ci",    false],
240 |                [133, "ucs2",     "ucs2_polish_ci",       false],
241 |                [134, "ucs2",     "ucs2_estonian_ci",     false],
242 |                [135, "ucs2",     "ucs2_spanish_ci",      false],
243 |                [136, "ucs2",     "ucs2_swedish_ci",      false],
244 |                [137, "ucs2",     "ucs2_turkish_ci",      false],
245 |                [138, "ucs2",     "ucs2_czech_ci",        false],
246 |                [139, "ucs2",     "ucs2_danish_ci",       false],
247 |                [140, "ucs2",     "ucs2_lithuanian_ci",   false],
248 |                [141, "ucs2",     "ucs2_slovak_ci",       false],
249 |                [142, "ucs2",     "ucs2_spanish2_ci",     false],
250 |                [143, "ucs2",     "ucs2_roman_ci",        false],
251 |                [144, "ucs2",     "ucs2_persian_ci",      false],
252 |                [145, "ucs2",     "ucs2_esperanto_ci",    false],
253 |                [146, "ucs2",     "ucs2_hungarian_ci",    false],
254 |                [192, "utf8",     "utf8_unicode_ci",      false],
255 |                [193, "utf8",     "utf8_icelandic_ci",    false],
256 |                [194, "utf8",     "utf8_latvian_ci",      false],
257 |                [195, "utf8",     "utf8_romanian_ci",     false],
258 |                [196, "utf8",     "utf8_slovenian_ci",    false],
259 |                [197, "utf8",     "utf8_polish_ci",       false],
260 |                [198, "utf8",     "utf8_estonian_ci",     false],
261 |                [199, "utf8",     "utf8_spanish_ci",      false],
262 |                [200, "utf8",     "utf8_swedish_ci",      false],
263 |                [201, "utf8",     "utf8_turkish_ci",      false],
264 |                [202, "utf8",     "utf8_czech_ci",        false],
265 |                [203, "utf8",     "utf8_danish_ci",       false],
266 |                [204, "utf8",     "utf8_lithuanian_ci",   false],
267 |                [205, "utf8",     "utf8_slovak_ci",       false],
268 |                [206, "utf8",     "utf8_spanish2_ci",     false],
269 |                [207, "utf8",     "utf8_roman_ci",        false],
270 |                [208, "utf8",     "utf8_persian_ci",      false],
271 |                [209, "utf8",     "utf8_esperanto_ci",    false],
272 |                [210, "utf8",     "utf8_hungarian_ci",    false],
273 |                [254, "utf8",     "utf8_general_cs",      false],
274 |               ];
275 | 
276 | 
277 | 
278 | /*
279 | node-mysql
280 | A node.js interface for MySQL
281 | http://github.com/masuidrive/node-mysql
282 | 
283 | Copyright (c) Yuichiro MASUI <masui@masuidrive.jp>
284 | License: MIT License
285 | 
286 | # Original:
287 | # http://github.com/tmtm/ruby-mysql
288 | # Copyright (C) 2009-2010 TOMITA Masahiro
289 | # mailto:tommy@tmtm.org
290 | # License: Ruby's
291 | */
292 | 


--------------------------------------------------------------------------------
/lib/mysql/connection.js:
--------------------------------------------------------------------------------
  1 | // RawConnection: 
  2 | // MySQL packet I/O
  3 | // http://forge.mysql.com/wiki/MySQL_Internals_ClientServer_Protocol#The_Packet_Header
  4 | var sys = require('sys');
  5 | var events = require("events");
  6 | var pack = require('./pack');
  7 | var utils = require('./utils');
  8 | var errors = require('./errors');
  9 | var Promise = require('./node-promise').Promise;
 10 | var Socket = require('./node-socket').Socket;
 11 | 
 12 | 
 13 | var MAX_PACKET_LENGTH = 16777215;
 14 | 
 15 | var Connection = function(port, hostname) {
 16 |     events.EventEmitter.call(this);
 17 |     this.hostname = hostname;
 18 |     this.port = port;
 19 |     this.seq = 0; // packet sequence number
 20 |     this.socket = new Socket(utils.scope(this, function(){ this.emit("connect"); }),
 21 | 			     utils.scope(this, function(){ this.emit("close"); }));
 22 | }
 23 | sys.inherits(Connection, events.EventEmitter);
 24 | exports.Connection = Connection;
 25 | 
 26 | // set timeout
 27 | Connection.prototype.timeout = function(timeout) {
 28 |     this.socket.timeout(timeout);
 29 | }
 30 | 
 31 | // open TCP socket
 32 | Connection.prototype.connect = function() {
 33 |     this.socket.connect(this.port, this.hostname);
 34 | }
 35 | 
 36 | // reset packet sequence
 37 | Connection.prototype.reset = function() {
 38 |     this.seq = 0;
 39 | }
 40 | 
 41 | // close TCP socket
 42 | Connection.prototype.close = function() {
 43 |     this.socket.close();
 44 | }
 45 | 
 46 | // Either "closed", "open", "opening", "readOnly", or "writeOnly". 
 47 | Connection.prototype.readyState = function() {
 48 |     return this.socket.readyState();
 49 | }
 50 | 
 51 | // Read one packet data
 52 | Connection.prototype.read = function(packet_count) {
 53 |     var promise = new Promise();
 54 |     var ret = "";
 55 |     var len = undefined;
 56 |     var packets = [];
 57 |     var read_packet = utils.scope(this, function() {
 58 | 	try {
 59 | 	    this.socket.read(4)
 60 | 		.addCallback(utils.scope(this, function(header) {
 61 | 		    try {
 62 | 			var res = pack.unpack("CvC", header);
 63 | 			len = (res[1] << 8) + res[0];
 64 | 			if(res[2] != this.seq) {
 65 | 			    promise.emitError(new errors.ProtocolError("invalid packet: sequence number mismatch("+res[2]+" != "+this.seq+"(expected))"));
 66 | 			    return;
 67 | 			}
 68 | 			this.seq = (res[2] + 1) % 256;
 69 | 			this.socket.read(len)
 70 | 			    .addCallback(utils.scope(this, function(data) {
 71 | 				try {
 72 | 				    ret = ret.concat(data);
 73 | 				    var sqlstate = "00000";
 74 | 				    // Error packet
 75 | 				    if(ret[0]=="\xff") {
 76 | 					var res = pack.unpack("Cvaa5a*", ret);
 77 | 					var f = res[0], errno = res[1], marker = res[2], sqlstate = res[3], message = res[4];
 78 | 					if(marker!="#") {
 79 | 					    res = pack.unpack("Cva*", ret);    // Version 4.0 Error
 80 | 					    f = res[0], errno = res[1], message = res[2]; 
 81 | 					    sqlstate = "";
 82 | 					}
 83 | 					promise.emitError(new errors.ServerError(message, errno, sqlstate));
 84 | 				    }
 85 | 				    else {
 86 | 					packets.push(ret);
 87 | 					if(typeof(packet_count)=='undefined') {
 88 | 					    promise.emitSuccess(ret);
 89 | 					}
 90 | 					else if(packets.length>=packet_count) {
 91 | 					    promise.emitSuccess(packets);
 92 | 					}
 93 | 					else {
 94 | 					    read_packet();
 95 | 					}
 96 | 				    }
 97 | 				}
 98 | 				catch(e) {
 99 | 				    promise.emitError(new errors.ClientError(String(e)));
100 | 				}
101 | 			    }))
102 | 			    .addErrback(utils.scope(this, function(error) {
103 | 				promise.emitError(error);
104 | 			    }));
105 | 		    }
106 | 		    catch(e) {
107 | 			promise.emitError(new errors.ClientError(String(e)));
108 | 		    }
109 | 	    }))
110 | 	    .addErrback(utils.scope(this, function(error) {
111 | 		promise.emitError(error);
112 | 	    }));
113 | 	}
114 | 	catch(e) {
115 | 	    promise.emitError(new errors.ClientError(String(e)));
116 | 	}
117 |     });
118 |     read_packet();
119 |     return promise;
120 | }
121 | 
122 | 
123 | // Write one packet data
124 | Connection.prototype.write = function(data) {
125 |     try {
126 | 	var promise = new Promise();
127 | 	if(typeof(data)=='undefined') {
128 | 	    this.socket.write(pack.pack("CvC", 0, 0, this.seq));
129 | 	    this.seq = (this.seq + 1) % 256
130 | 	    promise.emitSuccess();
131 | 	}
132 | 	else {
133 | 	    var buf;
134 | 	    while(data) {
135 | 		buf = data.substring(0, MAX_PACKET_LENGTH);
136 | 		data = data.slice(MAX_PACKET_LENGTH);
137 | 		this.socket.write(pack.pack("CvC", buf.length%256, buf.length/256, this.seq));
138 | 		this.socket.write(buf);
139 | 		this.seq = (this.seq + 1) % 256;
140 | 	    }
141 | 	    promise.emitSuccess();
142 | 	}
143 |     }
144 |     catch(e) {
145 | 	promise.emitError(new errors.ClientError(String(e)));
146 |     }
147 |     return promise;
148 | }
149 | 
150 | 
151 | /*
152 | node-mysql
153 | A node.js interface for MySQL
154 | 
155 | Author: masuidrive <masui@masuidrive.jp>
156 | License: MIT License
157 | Copyright (c) Yuichiro MASUI
158 | 
159 | # Original:
160 | # http://github.com/tmtm/ruby-mysql
161 | # Copyright (C) 2009-2010 TOMITA Masahiro
162 | # mailto:tommy@tmtm.org
163 | # License: Ruby's
164 | */
165 | 


--------------------------------------------------------------------------------
/lib/mysql/constants.js:
--------------------------------------------------------------------------------
  1 | exports.com = {
  2 |     SLEEP               : 0,
  3 |     QUIT                : 1,
  4 |     INIT_DB             : 2,
  5 |     QUERY               : 3,
  6 |     FIELD_LIST          : 4,
  7 |     CREATE_DB           : 5,
  8 |     DROP_DB             : 6,
  9 |     REFRESH             : 7,
 10 |     SHUTDOWN            : 8,
 11 |     STATISTICS          : 9,
 12 |     PROCESS_INFO        : 10,
 13 |     CONNECT             : 11,
 14 |     PROCESS_KILL        : 12,
 15 |     DEBUG               : 13,
 16 |     PING                : 14,
 17 |     TIME                : 15,
 18 |     DELAYED_INSERT      : 16,
 19 |     CHANGE_USER         : 17,
 20 |     BINLOG_DUMP         : 18,
 21 |     TABLE_DUMP          : 19,
 22 |     CONNECT_OUT         : 20,
 23 |     REGISTER_SLAVE      : 21,
 24 |     STMT_PREPARE        : 22,
 25 |     STMT_EXECUTE        : 23,
 26 |     STMT_SEND_LONG_DATA : 24,
 27 |     STMT_CLOSE          : 25,
 28 |     STMT_RESET          : 26,
 29 |     SET_OPTION          : 27,
 30 |     STMT_FETCH          : 28
 31 | };
 32 | 
 33 | // Client flag
 34 | exports.client = {
 35 |     LONG_PASSWORD     : 1,         // new more secure passwords
 36 |     FOUND_ROWS        : 1 << 1,    // Found instead of affected rows
 37 |     LONG_FLAG         : 1 << 2,    // Get all column flags
 38 |     CONNECT_WITH_DB   : 1 << 3,    // One can specify db on connect
 39 |     NO_SCHEMA         : 1 << 4,    // Don't allow database.table.column
 40 |     COMPRESS          : 1 << 5,    // Can use compression protocol
 41 |     ODBC              : 1 << 6,    // Odbc client
 42 |     LOCAL_FILES       : 1 << 7,    // Can use LOAD DATA LOCAL
 43 |     IGNORE_SPACE      : 1 << 8,    // Ignore spaces before '('
 44 |     PROTOCOL_41       : 1 << 9,    // New 4.1 protocol
 45 |     INTERACTIVE       : 1 << 10,   // This is an interactive client
 46 |     SSL               : 1 << 11,   // Switch to SSL after handshake
 47 |     IGNORE_SIGPIPE    : 1 << 12,   // IGNORE sigpipes
 48 |     TRANSACTIONS      : 1 << 13,   // Client knows about transactions
 49 |     RESERVED          : 1 << 14,   // Old flag for 4.1 protocol
 50 |     SECURE_CONNECTION : 1 << 15,   // New 4.1 authentication
 51 |     MULTI_STATEMENTS  : 1 << 16,   // Enable/disable multi-stmt support
 52 |     MULTI_RESULTS     : 1 << 17   // Enable/disable multi-results
 53 | };
 54 | 
 55 | // Connection Option
 56 | exports.option = {
 57 |     OPT_CONNECT_TIMEOUT         : 0,
 58 |     OPT_COMPRESS                : 1,
 59 |     OPT_NAMED_PIPE              : 2,
 60 |     INIT_COMMAND                : 3,
 61 |     READ_DEFAULT_FILE           : 4,
 62 |     READ_DEFAULT_GROUP          : 5,
 63 |     SET_CHARSET_DIR             : 6,
 64 |     SET_CHARSET_NAME            : 7,
 65 |     OPT_LOCAL_INFILE            : 8,
 66 |     OPT_PROTOCOL                : 9,
 67 |     SHARED_MEMORY_BASE_NAME     : 10,
 68 |     OPT_READ_TIMEOUT            : 11,
 69 |     OPT_WRITE_TIMEOUT           : 12,
 70 |     OPT_USE_RESULT              : 13,
 71 |     OPT_USE_REMOTE_CONNECTION   : 14,
 72 |     OPT_USE_EMBEDDED_CONNECTION : 15,
 73 |     OPT_GUESS_CONNECTION        : 16,
 74 |     SET_CLIENT_IP               : 17,
 75 |     SECURE_AUTH                 : 18,
 76 |     REPORT_DATA_TRUNCATION      : 19,
 77 |     OPT_RECONNECT               : 20,
 78 |     OPT_SSL_VERIFY_SERVER_CERT  : 21,
 79 | 
 80 |     // Server Option,
 81 |     MULTI_STATEMENTS_ON         : 0,
 82 |     MULTI_STATEMENTS_OFF        : 1
 83 | };
 84 | 
 85 | // Server Status
 86 | exports.server = {
 87 |     STATUS_IN_TRANS             : 1,
 88 |     STATUS_AUTOCOMMIT           : 1 << 1,
 89 |     MORE_RESULTS_EXISTS         : 1 << 3,
 90 |     QUERY_NO_GOOD_INDEX_USED    : 1 << 4,
 91 |     QUERY_NO_INDEX_USED         : 1 << 5,
 92 |     STATUS_CURSOR_EXISTS        : 1 << 6,
 93 |     STATUS_LAST_ROW_SENT        : 1 << 7,
 94 |     STATUS_DB_DROPPED           : 1 << 8,
 95 |     STATUS_NO_BACKSLASH_ESCAPES : 1 << 9
 96 | };
 97 | 
 98 | // Refresh parameter
 99 | exports.refresh = {
100 |     GRANT     : 1,
101 |     LOG       : 1 << 1,
102 |     TABLES    : 1 << 2,
103 |     HOSTS     : 1 << 3,
104 |     STATUS    : 1 << 4,
105 |     THREADS   : 1 << 5,
106 |     SLAVE     : 1 << 6,
107 |     MASTER    : 1 << 7,
108 |     READ_LOCK : 1 << 14,
109 |     FAST      : 1 << 15
110 | };
111 | 
112 | exports.field = {
113 |   // Field type
114 |   TYPE_DECIMAL     : 0,
115 |   TYPE_TINY        : 1,
116 |   TYPE_SHORT       : 2,
117 |   TYPE_LONG        : 3,
118 |   TYPE_FLOAT       : 4,
119 |   TYPE_DOUBLE      : 5,
120 |   TYPE_NULL        : 6,
121 |   TYPE_TIMESTAMP   : 7,
122 |   TYPE_LONGLONG    : 8,
123 |   TYPE_INT24       : 9,
124 |   TYPE_DATE        : 10,
125 |   TYPE_TIME        : 11,
126 |   TYPE_DATETIME    : 12,
127 |   TYPE_YEAR        : 13,
128 |   TYPE_NEWDATE     : 14,
129 |   TYPE_VARCHAR     : 15,
130 |   TYPE_BIT         : 16,
131 |   TYPE_NEWDECIMAL  : 246,
132 |   TYPE_ENUM        : 247,
133 |   TYPE_SET         : 248,
134 |   TYPE_TINY_BLOB   : 249,
135 |   TYPE_MEDIUM_BLOB : 250,
136 |   TYPE_LONG_BLOB   : 251,
137 |   TYPE_BLOB        : 252,
138 |   TYPE_VAR_STRING  : 253,
139 |   TYPE_STRING      : 254,
140 |   TYPE_GEOMETRY    : 255,
141 |   TYPE_CHAR        : 1, // TYPE_TINY
142 |   TYPE_INTERVAL    : 247, // TYPE_ENUM
143 | 
144 |   // Flag
145 |   NOT_NULL_FLAG       : 1,
146 |   PRI_KEY_FLAG        : 1 << 1,
147 |   UNIQUE_KEY_FLAG     : 1 << 2,
148 |   MULTIPLE_KEY_FLAG   : 1 << 3,
149 |   BLOB_FLAG           : 1 << 4,
150 |   UNSIGNED_FLAG       : 1 << 5,
151 |   ZEROFILL_FLAG       : 1 << 6,
152 |   BINARY_FLAG         : 1 << 7,
153 |   ENUM_FLAG           : 1 << 8,
154 |   AUTO_INCREMENT_FLAG : 1 << 9,
155 |   TIMESTAMP_FLAG      : 1 << 10,
156 |   SET_FLAG            : 1 << 11,
157 |   
158 |   PART_KEY_FLAG       : 1 << 14,
159 |   NUM_FLAG            : 1 << 15,
160 |   GROUP_FLAG          : 1 << 15,
161 |   UNIQUE_FLAG         : 1 << 16,
162 |   BINCMP_FLAG         : 1 << 17,
163 | };
164 | 
165 | exports.stmt = {
166 |   // Cursor type
167 |   CURSOR_TYPE_NO_CURSOR : 0,
168 |   CURSOR_TYPE_READ_ONLY : 1
169 | };
170 | 
171 | 
172 | /*
173 | node-mysql
174 | A node.js interface for MySQL
175 | 
176 | Author: masuidrive <masui@masuidrive.jp>
177 | License: MIT License
178 | Copyright (c) Yuichiro MASUI
179 | 
180 | # Original:
181 | # http://github.com/tmtm/ruby-mysql
182 | # Copyright (C) 2009-2010 TOMITA Masahiro
183 | # mailto:tommy@tmtm.org
184 | # License: Ruby's
185 | */
186 | 


--------------------------------------------------------------------------------
/lib/mysql/errors.js:
--------------------------------------------------------------------------------
  1 | var ClientError = function(message) {
  2 |     this.message = message;
  3 | }
  4 | exports.ClientError = ClientError;
  5 | 
  6 | ClientError.prototype.toString = function() {
  7 |     return "ClientError: "+this.message;
  8 | }
  9 | 
 10 | var ProtocolError = function(message) {
 11 |     this.message = message;
 12 | }
 13 | exports.ProtocolError = ProtocolError;
 14 | 
 15 | ProtocolError.prototype.toString = function() {
 16 |     return "ProtocolError: "+this.message;
 17 | }
 18 | 
 19 | var map = {};
 20 | var ServerError = function(message, errno, sqlstate) {
 21 |     this.message = message;
 22 |     this.errno = errno;
 23 |     this.error_name = errno ? map[parseInt(errno)] : 'ER_UNKNOW';
 24 |     this.sqlstate = sqlstate;
 25 | }
 26 | exports.ServerError = ServerError;
 27 | 
 28 | ServerError.prototype.toString = function() {
 29 |     return "ServerError("+this.error_name+"): "+this.message+" ("+this.sqlstate+")";
 30 | }
 31 | 
 32 | 
 33 | 
 34 | map[0] = "ER_UNKNOW";
 35 | map[1000] = "ER_HASHCHK";
 36 | map[1001] = "ER_NISAMCHK";
 37 | map[1002] = "ER_NO";
 38 | map[1003] = "ER_YES";
 39 | map[1004] = "ER_CANT_CREATE_FILE";
 40 | map[1005] = "ER_CANT_CREATE_TABLE";
 41 | map[1006] = "ER_CANT_CREATE_DB";
 42 | map[1007] = "ER_DB_CREATE_EXISTS";
 43 | map[1008] = "ER_DB_DROP_EXISTS";
 44 | map[1009] = "ER_DB_DROP_DELETE";
 45 | map[1010] = "ER_DB_DROP_RMDIR";
 46 | map[1011] = "ER_CANT_DELETE_FILE";
 47 | map[1012] = "ER_CANT_FIND_SYSTEM_REC";
 48 | map[1013] = "ER_CANT_GET_STAT";
 49 | map[1014] = "ER_CANT_GET_WD";
 50 | map[1015] = "ER_CANT_LOCK";
 51 | map[1016] = "ER_CANT_OPEN_FILE";
 52 | map[1017] = "ER_FILE_NOT_FOUND";
 53 | map[1018] = "ER_CANT_READ_DIR";
 54 | map[1019] = "ER_CANT_SET_WD";
 55 | map[1020] = "ER_CHECKREAD";
 56 | map[1021] = "ER_DISK_FULL";
 57 | map[1022] = "ER_DUP_KEY";
 58 | map[1023] = "ER_ERROR_ON_CLOSE";
 59 | map[1024] = "ER_ERROR_ON_READ";
 60 | map[1025] = "ER_ERROR_ON_RENAME";
 61 | map[1026] = "ER_ERROR_ON_WRITE";
 62 | map[1027] = "ER_FILE_USED";
 63 | map[1028] = "ER_FILSORT_ABORT";
 64 | map[1029] = "ER_FORM_NOT_FOUND";
 65 | map[1030] = "ER_GET_ERRNO";
 66 | map[1031] = "ER_ILLEGAL_HA";
 67 | map[1032] = "ER_KEY_NOT_FOUND";
 68 | map[1033] = "ER_NOT_FORM_FILE";
 69 | map[1034] = "ER_NOT_KEYFILE";
 70 | map[1035] = "ER_OLD_KEYFILE";
 71 | map[1036] = "ER_OPEN_AS_READONLY";
 72 | map[1037] = "ER_OUTOFMEMORY";
 73 | map[1038] = "ER_OUT_OF_SORTMEMORY";
 74 | map[1039] = "ER_UNEXPECTED_EOF";
 75 | map[1040] = "ER_CON_COUNT_ERROR";
 76 | map[1041] = "ER_OUT_OF_RESOURCES";
 77 | map[1042] = "ER_BAD_HOST_ERROR";
 78 | map[1043] = "ER_HANDSHAKE_ERROR";
 79 | map[1044] = "ER_DBACCESS_DENIED_ERROR";
 80 | map[1045] = "ER_ACCESS_DENIED_ERROR";
 81 | map[1046] = "ER_NO_DB_ERROR";
 82 | map[1047] = "ER_UNKNOWN_COM_ERROR";
 83 | map[1048] = "ER_BAD_NULL_ERROR";
 84 | map[1049] = "ER_BAD_DB_ERROR";
 85 | map[1050] = "ER_TABLE_EXISTS_ERROR";
 86 | map[1051] = "ER_BAD_TABLE_ERROR";
 87 | map[1052] = "ER_NON_UNIQ_ERROR";
 88 | map[1053] = "ER_SERVER_SHUTDOWN";
 89 | map[1054] = "ER_BAD_FIELD_ERROR";
 90 | map[1055] = "ER_WRONG_FIELD_WITH_GROUP";
 91 | map[1056] = "ER_WRONG_GROUP_FIELD";
 92 | map[1057] = "ER_WRONG_SUM_SELECT";
 93 | map[1058] = "ER_WRONG_VALUE_COUNT";
 94 | map[1059] = "ER_TOO_LONG_IDENT";
 95 | map[1060] = "ER_DUP_FIELDNAME";
 96 | map[1061] = "ER_DUP_KEYNAME";
 97 | map[1062] = "ER_DUP_ENTRY";
 98 | map[1063] = "ER_WRONG_FIELD_SPEC";
 99 | map[1064] = "ER_PARSE_ERROR";
100 | map[1065] = "ER_EMPTY_QUERY";
101 | map[1066] = "ER_NONUNIQ_TABLE";
102 | map[1067] = "ER_INVALID_DEFAULT";
103 | map[1068] = "ER_MULTIPLE_PRI_KEY";
104 | map[1069] = "ER_TOO_MANY_KEYS";
105 | map[1070] = "ER_TOO_MANY_KEY_PARTS";
106 | map[1071] = "ER_TOO_LONG_KEY";
107 | map[1072] = "ER_KEY_COLUMN_DOES_NOT_EXITS";
108 | map[1073] = "ER_BLOB_USED_AS_KEY";
109 | map[1074] = "ER_TOO_BIG_FIELDLENGTH";
110 | map[1075] = "ER_WRONG_AUTO_KEY";
111 | map[1076] = "ER_READY";
112 | map[1077] = "ER_NORMAL_SHUTDOWN";
113 | map[1078] = "ER_GOT_SIGNAL";
114 | map[1079] = "ER_SHUTDOWN_COMPLETE";
115 | map[1080] = "ER_FORCING_CLOSE";
116 | map[1081] = "ER_IPSOCK_ERROR";
117 | map[1082] = "ER_NO_SUCH_INDEX";
118 | map[1083] = "ER_WRONG_FIELD_TERMINATORS";
119 | map[1084] = "ER_BLOBS_AND_NO_TERMINATED";
120 | map[1085] = "ER_TEXTFILE_NOT_READABLE";
121 | map[1086] = "ER_FILE_EXISTS_ERROR";
122 | map[1087] = "ER_LOAD_INFO";
123 | map[1088] = "ER_ALTER_INFO";
124 | map[1089] = "ER_WRONG_SUB_KEY";
125 | map[1090] = "ER_CANT_REMOVE_ALL_FIELDS";
126 | map[1091] = "ER_CANT_DROP_FIELD_OR_KEY";
127 | map[1092] = "ER_INSERT_INFO";
128 | map[1093] = "ER_UPDATE_TABLE_USED";
129 | map[1094] = "ER_NO_SUCH_THREAD";
130 | map[1095] = "ER_KILL_DENIED_ERROR";
131 | map[1096] = "ER_NO_TABLES_USED";
132 | map[1097] = "ER_TOO_BIG_SET";
133 | map[1098] = "ER_NO_UNIQUE_LOGFILE";
134 | map[1099] = "ER_TABLE_NOT_LOCKED_FOR_WRITE";
135 | map[1100] = "ER_TABLE_NOT_LOCKED";
136 | map[1101] = "ER_BLOB_CANT_HAVE_DEFAULT";
137 | map[1102] = "ER_WRONG_DB_NAME";
138 | map[1103] = "ER_WRONG_TABLE_NAME";
139 | map[1104] = "ER_TOO_BIG_SELECT";
140 | map[1105] = "ER_UNKNOWN_ERROR";
141 | map[1106] = "ER_UNKNOWN_PROCEDURE";
142 | map[1107] = "ER_WRONG_PARAMCOUNT_TO_PROCEDURE";
143 | map[1108] = "ER_WRONG_PARAMETERS_TO_PROCEDURE";
144 | map[1109] = "ER_UNKNOWN_TABLE";
145 | map[1110] = "ER_FIELD_SPECIFIED_TWICE";
146 | map[1111] = "ER_INVALID_GROUP_FUNC_USE";
147 | map[1112] = "ER_UNSUPPORTED_EXTENSION";
148 | map[1113] = "ER_TABLE_MUST_HAVE_COLUMNS";
149 | map[1114] = "ER_RECORD_FILE_FULL";
150 | map[1115] = "ER_UNKNOWN_CHARACTER_SET";
151 | map[1116] = "ER_TOO_MANY_TABLES";
152 | map[1117] = "ER_TOO_MANY_FIELDS";
153 | map[1118] = "ER_TOO_BIG_ROWSIZE";
154 | map[1119] = "ER_STACK_OVERRUN";
155 | map[1120] = "ER_WRONG_OUTER_JOIN";
156 | map[1121] = "ER_NULL_COLUMN_IN_INDEX";
157 | map[1122] = "ER_CANT_FIND_UDF";
158 | map[1123] = "ER_CANT_INITIALIZE_UDF";
159 | map[1124] = "ER_UDF_NO_PATHS";
160 | map[1125] = "ER_UDF_EXISTS";
161 | map[1126] = "ER_CANT_OPEN_LIBRARY";
162 | map[1127] = "ER_CANT_FIND_DL_ENTRY";
163 | map[1128] = "ER_FUNCTION_NOT_DEFINED";
164 | map[1129] = "ER_HOST_IS_BLOCKED";
165 | map[1130] = "ER_HOST_NOT_PRIVILEGED";
166 | map[1131] = "ER_PASSWORD_ANONYMOUS_USER";
167 | map[1132] = "ER_PASSWORD_NOT_ALLOWED";
168 | map[1133] = "ER_PASSWORD_NO_MATCH";
169 | map[1134] = "ER_UPDATE_INFO";
170 | map[1135] = "ER_CANT_CREATE_THREAD";
171 | map[1136] = "ER_WRONG_VALUE_COUNT_ON_ROW";
172 | map[1137] = "ER_CANT_REOPEN_TABLE";
173 | map[1138] = "ER_INVALID_USE_OF_NULL";
174 | map[1139] = "ER_REGEXP_ERROR";
175 | map[1140] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS";
176 | map[1141] = "ER_NONEXISTING_GRANT";
177 | map[1142] = "ER_TABLEACCESS_DENIED_ERROR";
178 | map[1143] = "ER_COLUMNACCESS_DENIED_ERROR";
179 | map[1144] = "ER_ILLEGAL_GRANT_FOR_TABLE";
180 | map[1145] = "ER_GRANT_WRONG_HOST_OR_USER";
181 | map[1146] = "ER_NO_SUCH_TABLE";
182 | map[1147] = "ER_NONEXISTING_TABLE_GRANT";
183 | map[1148] = "ER_NOT_ALLOWED_COMMAND";
184 | map[1149] = "ER_SYNTAX_ERROR";
185 | map[1150] = "ER_DELAYED_CANT_CHANGE_LOCK";
186 | map[1151] = "ER_TOO_MANY_DELAYED_THREADS";
187 | map[1152] = "ER_ABORTING_CONNECTION";
188 | map[1153] = "ER_NET_PACKET_TOO_LARGE";
189 | map[1154] = "ER_NET_READ_ERROR_FROM_PIPE";
190 | map[1155] = "ER_NET_FCNTL_ERROR";
191 | map[1156] = "ER_NET_PACKETS_OUT_OF_ORDER";
192 | map[1157] = "ER_NET_UNCOMPRESS_ERROR";
193 | map[1158] = "ER_NET_READ_ERROR";
194 | map[1159] = "ER_NET_READ_INTERRUPTED";
195 | map[1160] = "ER_NET_ERROR_ON_WRITE";
196 | map[1161] = "ER_NET_WRITE_INTERRUPTED";
197 | map[1162] = "ER_TOO_LONG_STRING";
198 | map[1163] = "ER_TABLE_CANT_HANDLE_BLOB";
199 | map[1164] = "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT";
200 | map[1165] = "ER_DELAYED_INSERT_TABLE_LOCKED";
201 | map[1166] = "ER_WRONG_COLUMN_NAME";
202 | map[1167] = "ER_WRONG_KEY_COLUMN";
203 | map[1168] = "ER_WRONG_MRG_TABLE";
204 | map[1169] = "ER_DUP_UNIQUE";
205 | map[1170] = "ER_BLOB_KEY_WITHOUT_LENGTH";
206 | map[1171] = "ER_PRIMARY_CANT_HAVE_NULL";
207 | map[1172] = "ER_TOO_MANY_ROWS";
208 | map[1173] = "ER_REQUIRES_PRIMARY_KEY";
209 | map[1174] = "ER_NO_RAID_COMPILED";
210 | map[1175] = "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE";
211 | map[1176] = "ER_KEY_DOES_NOT_EXITS";
212 | map[1177] = "ER_CHECK_NO_SUCH_TABLE";
213 | map[1178] = "ER_CHECK_NOT_IMPLEMENTED";
214 | map[1179] = "ER_CANT_DO_THIS_DURING_AN_TRANSACTION";
215 | map[1180] = "ER_ERROR_DURING_COMMIT";
216 | map[1181] = "ER_ERROR_DURING_ROLLBACK";
217 | map[1182] = "ER_ERROR_DURING_FLUSH_LOGS";
218 | map[1183] = "ER_ERROR_DURING_CHECKPOINT";
219 | map[1184] = "ER_NEW_ABORTING_CONNECTION";
220 | map[1185] = "ER_DUMP_NOT_IMPLEMENTED";
221 | map[1186] = "ER_FLUSH_MASTER_BINLOG_CLOSED";
222 | map[1187] = "ER_INDEX_REBUILD";
223 | map[1188] = "ER_MASTER";
224 | map[1189] = "ER_MASTER_NET_READ";
225 | map[1190] = "ER_MASTER_NET_WRITE";
226 | map[1191] = "ER_FT_MATCHING_KEY_NOT_FOUND";
227 | map[1192] = "ER_LOCK_OR_ACTIVE_TRANSACTION";
228 | map[1193] = "ER_UNKNOWN_SYSTEM_VARIABLE";
229 | map[1194] = "ER_CRASHED_ON_USAGE";
230 | map[1195] = "ER_CRASHED_ON_REPAIR";
231 | map[1196] = "ER_WARNING_NOT_COMPLETE_ROLLBACK";
232 | map[1197] = "ER_TRANS_CACHE_FULL";
233 | map[1198] = "ER_SLAVE_MUST_STOP";
234 | map[1199] = "ER_SLAVE_NOT_RUNNING";
235 | map[1200] = "ER_BAD_SLAVE";
236 | map[1201] = "ER_MASTER_INFO";
237 | map[1202] = "ER_SLAVE_THREAD";
238 | map[1203] = "ER_TOO_MANY_USER_CONNECTIONS";
239 | map[1204] = "ER_SET_CONSTANTS_ONLY";
240 | map[1205] = "ER_LOCK_WAIT_TIMEOUT";
241 | map[1206] = "ER_LOCK_TABLE_FULL";
242 | map[1207] = "ER_READ_ONLY_TRANSACTION";
243 | map[1208] = "ER_DROP_DB_WITH_READ_LOCK";
244 | map[1209] = "ER_CREATE_DB_WITH_READ_LOCK";
245 | map[1210] = "ER_WRONG_ARGUMENTS";
246 | map[1211] = "ER_NO_PERMISSION_TO_CREATE_USER";
247 | map[1212] = "ER_UNION_TABLES_IN_DIFFERENT_DIR";
248 | map[1213] = "ER_LOCK_DEADLOCK";
249 | map[1214] = "ER_TABLE_CANT_HANDLE_FT";
250 | map[1215] = "ER_CANNOT_ADD_FOREIGN";
251 | map[1216] = "ER_NO_REFERENCED_ROW";
252 | map[1217] = "ER_ROW_IS_REFERENCED";
253 | map[1218] = "ER_CONNECT_TO_MASTER";
254 | map[1219] = "ER_QUERY_ON_MASTER";
255 | map[1220] = "ER_ERROR_WHEN_EXECUTING_COMMAND";
256 | map[1221] = "ER_WRONG_USAGE";
257 | map[1222] = "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT";
258 | map[1223] = "ER_CANT_UPDATE_WITH_READLOCK";
259 | map[1224] = "ER_MIXING_NOT_ALLOWED";
260 | map[1225] = "ER_DUP_ARGUMENT";
261 | map[1226] = "ER_USER_LIMIT_REACHED";
262 | map[1227] = "ER_SPECIFIC_ACCESS_DENIED_ERROR";
263 | map[1228] = "ER_LOCAL_VARIABLE";
264 | map[1229] = "ER_GLOBAL_VARIABLE";
265 | map[1230] = "ER_NO_DEFAULT";
266 | map[1231] = "ER_WRONG_VALUE_FOR_VAR";
267 | map[1232] = "ER_WRONG_TYPE_FOR_VAR";
268 | map[1233] = "ER_VAR_CANT_BE_READ";
269 | map[1234] = "ER_CANT_USE_OPTION_HERE";
270 | map[1235] = "ER_NOT_SUPPORTED_YET";
271 | map[1236] = "ER_MASTER_FATAL_ERROR_READING_BINLOG";
272 | map[1237] = "ER_SLAVE_IGNORED_TABLE";
273 | map[1238] = "ER_INCORRECT_GLOBAL_LOCAL_VAR";
274 | map[1239] = "ER_WRONG_FK_DEF";
275 | map[1240] = "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF";
276 | map[1241] = "ER_OPERAND_COLUMNS";
277 | map[1242] = "ER_SUBQUERY_NO_1_ROW";
278 | map[1243] = "ER_UNKNOWN_STMT_HANDLER";
279 | map[1244] = "ER_CORRUPT_HELP_DB";
280 | map[1245] = "ER_CYCLIC_REFERENCE";
281 | map[1246] = "ER_AUTO_CONVERT";
282 | map[1247] = "ER_ILLEGAL_REFERENCE";
283 | map[1248] = "ER_DERIVED_MUST_HAVE_ALIAS";
284 | map[1249] = "ER_SELECT_REDUCED";
285 | map[1250] = "ER_TABLENAME_NOT_ALLOWED_HERE";
286 | map[1251] = "ER_NOT_SUPPORTED_AUTH_MODE";
287 | map[1252] = "ER_SPATIAL_CANT_HAVE_NULL";
288 | map[1253] = "ER_COLLATION_CHARSET_MISMATCH";
289 | map[1254] = "ER_SLAVE_WAS_RUNNING";
290 | map[1255] = "ER_SLAVE_WAS_NOT_RUNNING";
291 | map[1256] = "ER_TOO_BIG_FOR_UNCOMPRESS";
292 | map[1257] = "ER_ZLIB_Z_MEM_ERROR";
293 | map[1258] = "ER_ZLIB_Z_BUF_ERROR";
294 | map[1259] = "ER_ZLIB_Z_DATA_ERROR";
295 | map[1260] = "ER_CUT_VALUE_GROUP_CONCAT";
296 | map[1261] = "ER_WARN_TOO_FEW_RECORDS";
297 | map[1262] = "ER_WARN_TOO_MANY_RECORDS";
298 | map[1263] = "ER_WARN_NULL_TO_NOTNULL";
299 | map[1264] = "ER_WARN_DATA_OUT_OF_RANGE";
300 | map[1265] = "WARN_DATA_TRUNCATED";
301 | map[1266] = "ER_WARN_USING_OTHER_HANDLER";
302 | map[1267] = "ER_CANT_AGGREGATE_2COLLATIONS";
303 | map[1268] = "ER_DROP_USER";
304 | map[1269] = "ER_REVOKE_GRANTS";
305 | map[1270] = "ER_CANT_AGGREGATE_3COLLATIONS";
306 | map[1271] = "ER_CANT_AGGREGATE_NCOLLATIONS";
307 | map[1272] = "ER_VARIABLE_IS_NOT_STRUCT";
308 | map[1273] = "ER_UNKNOWN_COLLATION";
309 | map[1274] = "ER_SLAVE_IGNORED_SSL_PARAMS";
310 | map[1275] = "ER_SERVER_IS_IN_SECURE_AUTH_MODE";
311 | map[1276] = "ER_WARN_FIELD_RESOLVED";
312 | map[1277] = "ER_BAD_SLAVE_UNTIL_COND";
313 | map[1278] = "ER_MISSING_SKIP_SLAVE";
314 | map[1279] = "ER_UNTIL_COND_IGNORED";
315 | map[1280] = "ER_WRONG_NAME_FOR_INDEX";
316 | map[1281] = "ER_WRONG_NAME_FOR_CATALOG";
317 | map[1282] = "ER_WARN_QC_RESIZE";
318 | map[1283] = "ER_BAD_FT_COLUMN";
319 | map[1284] = "ER_UNKNOWN_KEY_CACHE";
320 | map[1285] = "ER_WARN_HOSTNAME_WONT_WORK";
321 | map[1286] = "ER_UNKNOWN_STORAGE_ENGINE";
322 | map[1287] = "ER_WARN_DEPRECATED_SYNTAX";
323 | map[1288] = "ER_NON_UPDATABLE_TABLE";
324 | map[1289] = "ER_FEATURE_DISABLED";
325 | map[1290] = "ER_OPTION_PREVENTS_STATEMENT";
326 | map[1291] = "ER_DUPLICATED_VALUE_IN_TYPE";
327 | map[1292] = "ER_TRUNCATED_WRONG_VALUE";
328 | map[1293] = "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS";
329 | map[1294] = "ER_INVALID_ON_UPDATE";
330 | map[1295] = "ER_UNSUPPORTED_PS";
331 | map[1296] = "ER_GET_ERRMSG";
332 | map[1297] = "ER_GET_TEMPORARY_ERRMSG";
333 | map[1298] = "ER_UNKNOWN_TIME_ZONE";
334 | map[1299] = "ER_WARN_INVALID_TIMESTAMP";
335 | map[1300] = "ER_INVALID_CHARACTER_STRING";
336 | map[1301] = "ER_WARN_ALLOWED_PACKET_OVERFLOWED";
337 | map[1302] = "ER_CONFLICTING_DECLARATIONS";
338 | map[1303] = "ER_SP_NO_RECURSIVE_CREATE";
339 | map[1304] = "ER_SP_ALREADY_EXISTS";
340 | map[1305] = "ER_SP_DOES_NOT_EXIST";
341 | map[1306] = "ER_SP_DROP_FAILED";
342 | map[1307] = "ER_SP_STORE_FAILED";
343 | map[1308] = "ER_SP_LILABEL_MISMATCH";
344 | map[1309] = "ER_SP_LABEL_REDEFINE";
345 | map[1310] = "ER_SP_LABEL_MISMATCH";
346 | map[1311] = "ER_SP_UNINIT_VAR";
347 | map[1312] = "ER_SP_BADSELECT";
348 | map[1313] = "ER_SP_BADRETURN";
349 | map[1314] = "ER_SP_BADSTATEMENT";
350 | map[1315] = "ER_UPDATE_LOG_DEPRECATED_IGNORED";
351 | map[1316] = "ER_UPDATE_LOG_DEPRECATED_TRANSLATED";
352 | map[1317] = "ER_QUERY_INTERRUPTED";
353 | map[1318] = "ER_SP_WRONG_NO_OF_ARGS";
354 | map[1319] = "ER_SP_COND_MISMATCH";
355 | map[1320] = "ER_SP_NORETURN";
356 | map[1321] = "ER_SP_NORETURNEND";
357 | map[1322] = "ER_SP_BAD_CURSOR_QUERY";
358 | map[1323] = "ER_SP_BAD_CURSOR_SELECT";
359 | map[1324] = "ER_SP_CURSOR_MISMATCH";
360 | map[1325] = "ER_SP_CURSOR_ALREADY_OPEN";
361 | map[1326] = "ER_SP_CURSOR_NOT_OPEN";
362 | map[1327] = "ER_SP_UNDECLARED_VAR";
363 | map[1328] = "ER_SP_WRONG_NO_OF_FETCH_ARGS";
364 | map[1329] = "ER_SP_FETCH_NO_DATA";
365 | map[1330] = "ER_SP_DUP_PARAM";
366 | map[1331] = "ER_SP_DUP_VAR";
367 | map[1332] = "ER_SP_DUP_COND";
368 | map[1333] = "ER_SP_DUP_CURS";
369 | map[1334] = "ER_SP_CANT_ALTER";
370 | map[1335] = "ER_SP_SUBSELECT_NYI";
371 | map[1336] = "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG";
372 | map[1337] = "ER_SP_VARCOND_AFTER_CURSHNDLR";
373 | map[1338] = "ER_SP_CURSOR_AFTER_HANDLER";
374 | map[1339] = "ER_SP_CASE_NOT_FOUND";
375 | map[1340] = "ER_FPARSER_TOO_BIG_FILE";
376 | map[1341] = "ER_FPARSER_BAD_HEADER";
377 | map[1342] = "ER_FPARSER_EOF_IN_COMMENT";
378 | map[1343] = "ER_FPARSER_ERROR_IN_PARAMETER";
379 | map[1344] = "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER";
380 | map[1345] = "ER_VIEW_NO_EXPLAIN";
381 | map[1346] = "ER_FRM_UNKNOWN_TYPE";
382 | map[1347] = "ER_WRONG_OBJECT";
383 | map[1348] = "ER_NONUPDATEABLE_COLUMN";
384 | map[1349] = "ER_VIEW_SELECT_DERIVED";
385 | map[1350] = "ER_VIEW_SELECT_CLAUSE";
386 | map[1351] = "ER_VIEW_SELECT_VARIABLE";
387 | map[1352] = "ER_VIEW_SELECT_TMPTABLE";
388 | map[1353] = "ER_VIEW_WRONG_LIST";
389 | map[1354] = "ER_WARN_VIEW_MERGE";
390 | map[1355] = "ER_WARN_VIEW_WITHOUT_KEY";
391 | map[1356] = "ER_VIEW_INVALID";
392 | map[1357] = "ER_SP_NO_DROP_SP";
393 | map[1358] = "ER_SP_GOTO_IN_HNDLR";
394 | map[1359] = "ER_TRG_ALREADY_EXISTS";
395 | map[1360] = "ER_TRG_DOES_NOT_EXIST";
396 | map[1361] = "ER_TRG_ON_VIEW_OR_TEMP_TABLE";
397 | map[1362] = "ER_TRG_CANT_CHANGE_ROW";
398 | map[1363] = "ER_TRG_NO_SUCH_ROW_IN_TRG";
399 | map[1364] = "ER_NO_DEFAULT_FOR_FIELD";
400 | map[1365] = "ER_DIVISION_BY_ZERO";
401 | map[1366] = "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD";
402 | map[1367] = "ER_ILLEGAL_VALUE_FOR_TYPE";
403 | map[1368] = "ER_VIEW_NONUPD_CHECK";
404 | map[1369] = "ER_VIEW_CHECK_FAILED";
405 | map[1370] = "ER_PROCACCESS_DENIED_ERROR";
406 | map[1371] = "ER_RELAY_LOG_FAIL";
407 | map[1372] = "ER_PASSWD_LENGTH";
408 | map[1373] = "ER_UNKNOWN_TARGET_BINLOG";
409 | map[1374] = "ER_IO_ERR_LOG_INDEX_READ";
410 | map[1375] = "ER_BINLOG_PURGE_PROHIBITED";
411 | map[1376] = "ER_FSEEK_FAIL";
412 | map[1377] = "ER_BINLOG_PURGE_FATAL_ERR";
413 | map[1378] = "ER_LOG_IN_USE";
414 | map[1379] = "ER_LOG_PURGE_UNKNOWN_ERR";
415 | map[1380] = "ER_RELAY_LOG_INIT";
416 | map[1381] = "ER_NO_BINARY_LOGGING";
417 | map[1382] = "ER_RESERVED_SYNTAX";
418 | map[1383] = "ER_WSAS_FAILED";
419 | map[1384] = "ER_DIFF_GROUPS_PROC";
420 | map[1385] = "ER_NO_GROUP_FOR_PROC";
421 | map[1386] = "ER_ORDER_WITH_PROC";
422 | map[1387] = "ER_LOGGING_PROHIBIT_CHANGING_OF";
423 | map[1388] = "ER_NO_FILE_MAPPING";
424 | map[1389] = "ER_WRONG_MAGIC";
425 | map[1390] = "ER_PS_MANY_PARAM";
426 | map[1391] = "ER_KEY_PART_0";
427 | map[1392] = "ER_VIEW_CHECKSUM";
428 | map[1393] = "ER_VIEW_MULTIUPDATE";
429 | map[1394] = "ER_VIEW_NO_INSERT_FIELD_LIST";
430 | map[1395] = "ER_VIEW_DELETE_MERGE_VIEW";
431 | map[1396] = "ER_CANNOT_USER";
432 | map[1397] = "ER_XAER_NOTA";
433 | map[1398] = "ER_XAER_INVAL";
434 | map[1399] = "ER_XAER_RMFAIL";
435 | map[1400] = "ER_XAER_OUTSIDE";
436 | map[1401] = "ER_XAER_RMERR";
437 | map[1402] = "ER_XA_RBROLLBACK";
438 | map[1403] = "ER_NONEXISTING_PROC_GRANT";
439 | map[1404] = "ER_PROC_AUTO_GRANT_FAIL";
440 | map[1405] = "ER_PROC_AUTO_REVOKE_FAIL";
441 | map[1406] = "ER_DATA_TOO_LONG";
442 | map[1407] = "ER_SP_BAD_SQLSTATE";
443 | map[1408] = "ER_STARTUP";
444 | map[1409] = "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR";
445 | map[1410] = "ER_CANT_CREATE_USER_WITH_GRANT";
446 | map[1411] = "ER_WRONG_VALUE_FOR_TYPE";
447 | map[1412] = "ER_TABLE_DEF_CHANGED";
448 | map[1413] = "ER_SP_DUP_HANDLER";
449 | map[1414] = "ER_SP_NOT_VAR_ARG";
450 | map[1415] = "ER_SP_NO_RETSET";
451 | map[1416] = "ER_CANT_CREATE_GEOMETRY_OBJECT";
452 | map[1417] = "ER_FAILED_ROUTINE_BREAK_BINLOG";
453 | map[1418] = "ER_BINLOG_UNSAFE_ROUTINE";
454 | map[1419] = "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER";
455 | map[1420] = "ER_EXEC_STMT_WITH_OPEN_CURSOR";
456 | map[1421] = "ER_STMT_HAS_NO_OPEN_CURSOR";
457 | map[1422] = "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG";
458 | map[1423] = "ER_NO_DEFAULT_FOR_VIEW_FIELD";
459 | map[1424] = "ER_SP_NO_RECURSION";
460 | map[1425] = "ER_TOO_BIG_SCALE";
461 | map[1426] = "ER_TOO_BIG_PRECISION";
462 | map[1427] = "ER_M_BIGGER_THAN_D";
463 | map[1428] = "ER_WRONG_LOCK_OF_SYSTEM_TABLE";
464 | map[1429] = "ER_CONNECT_TO_FOREIGN_DATA_SOURCE";
465 | map[1430] = "ER_QUERY_ON_FOREIGN_DATA_SOURCE";
466 | map[1431] = "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST";
467 | map[1432] = "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE";
468 | map[1433] = "ER_FOREIGN_DATA_STRING_INVALID";
469 | map[1434] = "ER_CANT_CREATE_FEDERATED_TABLE";
470 | map[1435] = "ER_TRG_IN_WRONG_SCHEMA";
471 | map[1436] = "ER_STACK_OVERRUN_NEED_MORE";
472 | map[1437] = "ER_TOO_LONG_BODY";
473 | map[1438] = "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE";
474 | map[1439] = "ER_TOO_BIG_DISPLAYWIDTH";
475 | map[1440] = "ER_XAER_DUPID";
476 | map[1441] = "ER_DATETIME_FUNCTION_OVERFLOW";
477 | map[1442] = "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG";
478 | map[1443] = "ER_VIEW_PREVENT_UPDATE";
479 | map[1444] = "ER_PS_NO_RECURSION";
480 | map[1445] = "ER_SP_CANT_SET_AUTOCOMMIT";
481 | map[1446] = "ER_MALFORMED_DEFINER";
482 | map[1447] = "ER_VIEW_FRM_NO_USER";
483 | map[1448] = "ER_VIEW_OTHER_USER";
484 | map[1449] = "ER_NO_SUCH_USER";
485 | map[1450] = "ER_FORBID_SCHEMA_CHANGE";
486 | map[1451] = "ER_ROW_IS_REFERENCED_2";
487 | map[1452] = "ER_NO_REFERENCED_ROW_2";
488 | map[1453] = "ER_SP_BAD_VAR_SHADOW";
489 | map[1454] = "ER_TRG_NO_DEFINER";
490 | map[1455] = "ER_OLD_FILE_FORMAT";
491 | map[1456] = "ER_SP_RECURSION_LIMIT";
492 | map[1457] = "ER_SP_PROC_TABLE_CORRUPT";
493 | map[1458] = "ER_SP_WRONG_NAME";
494 | map[1459] = "ER_TABLE_NEEDS_UPGRADE";
495 | map[1460] = "ER_SP_NO_AGGREGATE";
496 | map[1461] = "ER_MAX_PREPARED_STMT_COUNT_REACHED";
497 | map[1462] = "ER_VIEW_RECURSIVE";
498 | map[1463] = "ER_NON_GROUPING_FIELD_USED";
499 | map[1464] = "ER_TABLE_CANT_HANDLE_SPKEYS";
500 | map[1465] = "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA";
501 | map[1466] = "ER_REMOVED_SPACES";
502 | map[1467] = "ER_AUTOINC_READ_FAILED";
503 | map[1468] = "ER_USERNAME";
504 | map[1469] = "ER_HOSTNAME";
505 | map[1470] = "ER_WRONG_STRING_LENGTH";
506 | map[1471] = "ER_NON_INSERTABLE_TABLE";
507 | 
508 | exports.map = map;
509 | 
510 | 


--------------------------------------------------------------------------------
/lib/mysql/node-promise.js:
--------------------------------------------------------------------------------
  1 | // Promise library
  2 | // compatible with < 0.1.30
  3 | // It was changed for 
  4 | 
  5 | // Original:
  6 | // nodejs v0.1.29
  7 | // Copyright 2009, 2010 Ryan Lienhart Dahl. All rights reserved.
  8 | // MIT License
  9 | 
 10 | var sys = require('sys');
 11 | var events = require('events');
 12 | 
 13 | exports.Promise = function () {
 14 |     events.EventEmitter.call(this);
 15 |     this._blocking = false;
 16 |     this.hasFired = false;
 17 |     this._values = undefined;
 18 | };
 19 | sys.inherits(exports.Promise, events.EventEmitter);
 20 | 
 21 | exports.Promise.prototype.timeout = function(timeout, createError) {
 22 |     if (!timeout) {
 23 | 	return this._timeoutDuration;
 24 |     }
 25 |     
 26 |     this._timeoutDuration = timeout;
 27 |     
 28 |     if (this.hasFired) return;
 29 |     this._clearTimeout();
 30 |     
 31 |     var self = this;
 32 |     this._timer = setTimeout(function() {
 33 | 	self._timer = null;
 34 | 	if (self.hasFired) {
 35 |             return;
 36 | 	}
 37 | 	
 38 | 	self.emitError(createError ? createError() : new Error('timeout'));
 39 |     }, timeout/100);
 40 |     
 41 |     return this;
 42 | };
 43 | 
 44 | exports.Promise.prototype._clearTimeout = function() {
 45 |     if (!this._timer) return;
 46 |     
 47 |     clearTimeout(this._timer);
 48 |     this._timer = null;
 49 | }
 50 | 
 51 | exports.Promise.prototype.emitSuccess = function() {
 52 |     if (this.hasFired) return;
 53 |     this.hasFired = 'success';
 54 |     this._clearTimeout();
 55 |     
 56 |     this._values = Array.prototype.slice.call(arguments);
 57 |     this.emit.apply(this, ['success'].concat(this._values));
 58 | };
 59 | 
 60 | exports.Promise.prototype.emitError = function() {
 61 |     if (this.hasFired) return;
 62 |     this.hasFired = 'error';
 63 |     this._clearTimeout();
 64 |     
 65 |     this._values = Array.prototype.slice.call(arguments);
 66 |     this.emit.apply(this, ['error'].concat(this._values));
 67 |     
 68 |     if (this.listeners('error').length == 0) {
 69 | 	var self = this;
 70 | 	process.nextTick(function() {
 71 |             if (self.listeners('error').length == 0) {
 72 | 		throw (self._values[0] instanceof Error)
 73 | 		    ? self._values[0]
 74 | 		    : new Error('Unhandled emitError: '+JSON.stringify(self._values));
 75 |             }
 76 | 	});
 77 |     }
 78 | };
 79 | 
 80 | exports.Promise.prototype.addCallback = function (listener) {
 81 |     if(typeof(listener)=='undefined') return this;;
 82 |     if (this.hasFired === 'success') {
 83 | 	listener.apply(this, this._values);
 84 |     }
 85 |     return this.addListener("success", listener);
 86 | };
 87 | 
 88 | exports.Promise.prototype.addErrback = function (listener) {
 89 |     if(typeof(listener)=='undefined') return this;
 90 |     if (this.hasFired === 'error') {
 91 | 	listener.apply(this, this._values);
 92 |     }
 93 |     return this.addListener("error", listener);
 94 | };
 95 | 
 96 | /* Poor Man's coroutines */
 97 | var coroutineStack = [];
 98 | 
 99 | exports.Promise.prototype._destack = function () {
100 |     this._blocking = false;
101 |     
102 |     while (coroutineStack.length > 0 &&
103 |            !coroutineStack[coroutineStack.length-1]._blocking)
104 |     {
105 | 	coroutineStack.pop();
106 | 	process.unloop("one");
107 |     }
108 | };
109 | 


--------------------------------------------------------------------------------
/lib/mysql/node-socket.js:
--------------------------------------------------------------------------------
  1 | // 
  2 | // Append read() to tcp.Connection
  3 | //  
  4 | var sys = require('sys');
  5 | var tcp = require("net");
  6 | var events = require("events");
  7 | var errors = require('./errors');
  8 | var utils = require('./utils');
  9 | var Promise = require('./node-promise').Promise;
 10 | 
 11 | var Socket = function(connect_callback, close_callback) {
 12 |     this.conn = undefined;
 13 |     this._timeout = 0;
 14 |     this.buffer = '';
 15 |     this.read_queue = [];
 16 |     this.connect_callback = connect_callback;
 17 |     this.close_callback = close_callback;
 18 | }
 19 | sys.inherits(Socket, events.EventEmitter);
 20 | exports.Socket = Socket;
 21 | 
 22 | Socket.prototype.timeout = function(timeout) {
 23 |     this._timeout = timeout;
 24 | }
 25 | 
 26 | Socket.prototype.connect = function(port, host) {
 27 |     if(this.conn) {
 28 | 	throw "Already open";
 29 |     }
 30 |     else {
 31 | 	this.conn = tcp.createConnection(port, host);
 32 | 	this.conn.addListener("data", utils.scope(this, function(data) {
 33 | 	    this.buffer += data;
 34 | 	    this.process_tcp_read_queue();
 35 | 	}));
 36 | 	this.conn.addListener("connect", utils.scope(this, function(){
 37 | 	    this.conn.setEncoding("binary");
 38 | 	    this.conn.setNoDelay(true);
 39 | 	    this.conn.setTimeout(this._timeout);
 40 | 	    this.connect_callback();
 41 | 	}));
 42 | 	this.conn.addListener("close", utils.scope(this, function(hasError) {
 43 | 	    var task;
 44 | 	    while(task=this.read_queue.shift()) {
 45 | 		task.promise.emitError(new errors.ClientError('connection was closed'));
 46 | 	    }
 47 | 	    this.conn = undefined;
 48 | 	    this.close_callback(hasError);
 49 | 	}));
 50 |     }
 51 | }
 52 | 
 53 | Socket.prototype.readyState = function() {
 54 |     return this.conn.readyState;
 55 | }
 56 | 
 57 | Socket.prototype.close = function() {
 58 |     if(this.conn) this.conn.end();
 59 | }
 60 | 
 61 | Socket.prototype.read = function(len) {
 62 |     var promise = new Promise();
 63 |     if(this._timeout) promise.timeout(this._timeout, function(){ return new errors.ClientError('connection timeout'); });
 64 |     this.read_queue.push({len: len, promise: promise});
 65 |     if(this.buffer) this.process_tcp_read_queue();
 66 |     return promise;
 67 | }
 68 | 
 69 | Socket.prototype.process_tcp_read_queue = function() {
 70 |     if(this.read_queue.length==0) return;
 71 |     var task, data;
 72 |     if(typeof(this.read_queue[0].len)=='undefined') {
 73 | 	task = this.read_queue.shift();
 74 | 	data = this.buffer;
 75 | 	this.buffer = '';
 76 | 	task.promise.emitSuccess(data);
 77 |     }
 78 |     else if(this.buffer.length>=this.read_queue[0].len) {
 79 | 	task = this.read_queue.shift();
 80 | 	data = this.buffer.substring(0, task.len);
 81 | 	this.buffer = this.buffer.slice(task.len);
 82 | 	task.promise.emitSuccess(data);
 83 | 	this.process_tcp_read_queue();
 84 |     }
 85 | }
 86 | 
 87 | Socket.prototype.write = function(data) {
 88 |     this.conn.write(data, 'binary');
 89 | }
 90 | 
 91 | 
 92 | /*
 93 | node-mysql
 94 | A node.js interface for MySQL
 95 | 
 96 | Author: masuidrive <masui@masuidrive.jp>
 97 | License: MIT License
 98 | Copyright (c) Yuichiro MASUI
 99 | */
100 | 


--------------------------------------------------------------------------------
/lib/mysql/pack.js:
--------------------------------------------------------------------------------
  1 | // 
  2 | // pack/unpack style seralizer and deserializer.
  3 | //  
  4 | exports.unpack = function(format, data) {
  5 |     var result = [];
  6 |     var instruction, quantifier, currentData, i, j, k;
  7 |     
  8 |     while(format) {
  9 | 	instruction = format.substring(0,1);
 10 | 	format = format.slice(1);
 11 | 	quantifier = '1';
 12 | 	var q = format.match(/^(\*|\d+)/);
 13 | 	if(q!==null) {
 14 | 	    quantifier = q[0];
 15 | 	    format = format.slice(quantifier.length);
 16 | 	}
 17 |         switch (instruction) {
 18 |         case 'a': // NUL-padded string
 19 |         case 'A': // SPACE-padded string
 20 |         case 'Z': // 
 21 |             if (quantifier === '*') {
 22 | 		quantifier = data.indexOf( (instruction==='A'?" ":"\0"))+1;
 23 |                 if(!quantifier) quantifier = data.length;
 24 |             } else {
 25 |                 quantifier = parseInt(quantifier, 10);
 26 |             }
 27 |             currentData = data.substr(0, quantifier);
 28 |             data = data.slice(quantifier);
 29 | 	    
 30 |             if (instruction === 'a') {
 31 |                 currentResult = currentData.replace(/\0+$/, '');
 32 | 	    }
 33 |             else if (instruction === 'A') {
 34 |                 currentResult = currentData.replace(/ +$/, '');
 35 |             }
 36 | 	    else { // 'Z'
 37 | 		currentResult = currentData;
 38 | 	    }
 39 |             result.push(currentResult);
 40 |             break;
 41 | 	    
 42 |         case 'b': // 
 43 |             if (quantifier === '*') {
 44 |                 quantifier = data.length;
 45 |             } else {
 46 |                 quantifier = parseInt(quantifier, 10);
 47 |             }
 48 |             currentData = data.substr(0, quantifier);
 49 |             data = data.slice(quantifier);
 50 | 	    
 51 | 	    currentResult = '';
 52 |             for (i=0;i<currentData.length;i++) {
 53 | 		j = parseInt(currentData.charCodeAt(i));
 54 | 		for(k=0; k<8; ++k) {
 55 | 		    j <<= 1;
 56 | 		    currentResult += (j>255) ? "1" : "0";
 57 | 		    j &= 0xff;
 58 | 		}
 59 |             }
 60 |             result.push(currentResult);
 61 |             break;
 62 | 
 63 |         case 'c': // signed char
 64 |         case 'C': // unsigned c
 65 |             if (quantifier === '*') {
 66 |                 quantifier = data.length;
 67 |             } else {
 68 |                 quantifier = parseInt(quantifier, 10);
 69 |             }
 70 |             currentData = data.substr(0, quantifier);
 71 |             data = data.slice(quantifier);
 72 | 	    
 73 |             for (i=0;i<currentData.length;i++) {
 74 |                 currentResult = parseInt(currentData.charCodeAt(i));
 75 |                 if ((instruction === 'c') && (currentResult >= 128)) {
 76 |                     currentResult -= 256;
 77 |                 }
 78 |                 result.push(currentResult);
 79 |             }
 80 |             break;
 81 | 	    
 82 |         case 'v': // unsigned short (always 16 bit, little endian byte order)
 83 |             if (quantifier === '*') {
 84 |                 quantifier = (data.length) / 2;
 85 |             } else {
 86 |                 quantifier = parseInt(quantifier, 10);
 87 |             }
 88 |             currentData = data.substr(0, quantifier*2);
 89 |             data = data.slice(quantifier*2);
 90 |             for (i=0;i<currentData.length;i+=2) {
 91 |                 currentResult = parseInt(currentData.charCodeAt(i+1) << 8) +
 92 |                     parseInt(currentData.charCodeAt(i));
 93 |                 result.push(currentResult);
 94 |             }
 95 |             break;
 96 | 	    
 97 |         case 'V': // unsigned long (always 32 bit, little endian byte order)
 98 |             if (quantifier === '*') {
 99 |                 quantifier = (data.length) / 4;
100 |             } else {
101 |                 quantifier = parseInt(quantifier, 10);
102 |             }
103 | 	    
104 |             currentData = data.substr(0, quantifier*4);
105 |             data = data.slice(quantifier*4);
106 |             for (i=0;i<currentData.length;i+=4) {
107 |                 currentResult =
108 |                     parseInt((currentData.charCodeAt(i+3) & 0xFF) << 24) +
109 |                     parseInt((currentData.charCodeAt(i+2) & 0xFF) << 16) +
110 |                     parseInt((currentData.charCodeAt(i+1) & 0xFF) << 8) +
111 |                     parseInt((currentData.charCodeAt(i) & 0xFF));
112 |                 result.push(currentResult);
113 |             }
114 |             break;
115 | 	
116 | 	case 'e':
117 |             if (quantifier === '*') {
118 |                 quantifier = (data.length) / 4;
119 |             } else {
120 |                 quantifier = parseInt(quantifier, 10);
121 |             }
122 | 	    
123 |             currentData = data.substr(0, quantifier*4);
124 |             data = data.slice(quantifier*4);
125 |             for (i=0;i<currentData.length;i+=4) {
126 |                 currentResult = decodeIEEE754(currentData.substring(i*4, i*4+4));
127 |                 result.push(currentResult);
128 |             }
129 |             break;
130 | 	    
131 | 	case 'E':
132 |             if (quantifier === '*') {
133 |                 quantifier = (data.length) / 8;
134 |             } else {
135 |                 quantifier = parseInt(quantifier, 10);
136 |             }
137 | 	    
138 |             currentData = data.substr(0, quantifier*8);
139 |             data = data.slice(quantifier*8);
140 |             for (i=0;i<currentData.length;i+=8) {
141 |                 currentResult = decodeIEEE754(currentData.substring(i*8, i*8+8));
142 |                 result.push(currentResult);
143 |             }
144 |             break;
145 | 	    
146 |         default:
147 |             throw 'Warning:  unpack() Type ' + instruction + ': unknown format code';
148 | 	}
149 |     }
150 |     return result;
151 | };
152 | 
153 | 
154 | exports.pack = function(format) {
155 |     var result = "";
156 |     var instruction, quantifier, currentData;
157 |     var argumentPointer = 1;
158 |     var args = arguments;
159 |     if(args[1].constructor.toString().indexOf(" Array(") >= 0) {
160 | 	args = args[1];
161 | 	argumentPointer = 0;
162 |     }
163 |     
164 |     while(format) {
165 | 	instruction = format.substring(0,1);
166 | 	format = format.slice(1);
167 | 	quantifier = '1';
168 | 	var q = format.match(/^(\*|\d+)/);
169 | 	if(q!==null) {
170 | 	    quantifier = q[0];
171 | 	    format = format.slice(quantifier.length);
172 | 	}
173 | 	
174 | 	switch (instruction) {
175 |         case 'a': //NUL-padded string            
176 |         case 'A': //SPACE-padded string
177 |         case 'Z':
178 |             if (typeof args[argumentPointer] === 'undefined') {
179 |                 throw new Error('Warning: pack() Type ' + instruction +
180 |                        ': not enough arguments');
181 |             } else {
182 |                 argument = String(args[argumentPointer]);
183 |             }
184 |             if (quantifier === '*') {
185 |                 quantifier = argument.length + ((instruction === 'a') ? 1 : 0);
186 |             }
187 |             for (i = 0; i < quantifier; i ++) { 
188 | 		if (typeof(argument[i]) === 'undefined') {
189 |                     if (instruction === 'a') {
190 |                         result += String.fromCharCode(0);
191 |                     } else {
192 |                         result += ' ';
193 |                     }
194 |                 } else {
195 |                     result += argument[i];
196 |                 }
197 |             }
198 | 	    argumentPointer++;
199 |             break;
200 | 	    
201 |         case 'c': //signed char
202 |         case 'C': //unsigned char
203 |             //c and C is the same in pack
204 |             if (quantifier === '*') {
205 |                 quantifier = args.length - argumentPointer;
206 | 	    }
207 |             if (quantifier > (args.length - argumentPointer)) {
208 |                 throw new Error('Warning: pack() Type ' + instruction +
209 |                         ': too few arguments');
210 |             } 
211 |             for (i = 0; i < quantifier; i++) {
212 |                 result += String.fromCharCode(args[argumentPointer]);
213 |                 argumentPointer++;
214 |             }
215 | 	    break;
216 | 
217 |         case 'v':            //s and S is the same in pack
218 |             //but can machine byte order be retrieved in javascript?
219 |             //this is default byte order anywayz...
220 |             if (quantifier === '*') {
221 |                 quantifier = args.length - argumentPointer;
222 | 	    }
223 |             if (quantifier > (args.length - argumentPointer)) {
224 |                 throw new Error('Warning: pack() Type ' + instruction +
225 |                         ': too few arguments');
226 |             } 
227 |             for (i = 0; i < quantifier; i++) {
228 |                 result += String.fromCharCode(args[argumentPointer] &
229 |                         0xFF);
230 |                 result += String.fromCharCode(args[argumentPointer] >> 8 & 0xFF);
231 |                 argumentPointer++;
232 |             }
233 |             break;
234 | 	    
235 |         case 'V': // unsigned long (always 32 bit, little endian byte order)
236 |             if (quantifier === '*') {
237 |                 quantifier = args.length - argumentPointer;
238 | 	    }
239 |             if (quantifier > (args.length - argumentPointer)) {
240 |                 throw new Error('Warning: pack() Type ' + instruction +
241 |                         ': too few arguments');
242 |             } 
243 |             for (i = 0; i < quantifier; i++) {
244 |                 result += String.fromCharCode(args[argumentPointer] & 0xFF);
245 |                 result += String.fromCharCode(args[argumentPointer] >> 8 & 0xFF);
246 |                 result += String.fromCharCode(args[argumentPointer] >> 16 & 0xFF);
247 |                 result += String.fromCharCode(args[argumentPointer] >> 24 & 0xFF);
248 |                 argumentPointer++;
249 |             }
250 |             break;
251 | 
252 |         case 'e': // IEEE754 32bit
253 |             if (quantifier === '*') {
254 |                 quantifier = args.length - argumentPointer;
255 | 	    }
256 |             if (quantifier > (args.length - argumentPointer)) {
257 |                 throw new Error('Warning: pack() Type ' + instruction +
258 |                         ': too few arguments');
259 |             } 
260 | 
261 |             for (i = 0; i < quantifier; i++) {
262 | 		result += encodeIEEE754(args[argumentPointer], 'float');
263 |                 argumentPointer++;
264 |             }
265 |             break;
266 | 	    
267 |         case 'E': // IEEE754 64bit
268 |             if (quantifier === '*') {
269 |                 quantifier = args.length - argumentPointer;
270 | 	    }
271 |             if (quantifier > (args.length - argumentPointer)) {
272 |                 throw new Error('Warning: pack() Type ' + instruction +
273 |                         ': too few arguments');
274 |             } 
275 | 
276 |             for (i = 0; i < quantifier; i++) {
277 | 		result += encodeIEEE754(args[argumentPointer], 'double');
278 |                 argumentPointer++;
279 |             }
280 |             break;
281 | 
282 |         default:
283 |             throw 'Warning: pack() Type ' + instruction + ': unknown format code';
284 | 	}
285 |     }
286 |     return result;
287 | };
288 | 
289 | 
290 | var encodeIEEE754 = function(val, type) {
291 |     var config = {
292 | 	'double': {
293 | 	    bias: 1023,
294 | 	    bytes: 8,
295 | 	    exp: 11,
296 | 	    
297 | 	    POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
298 | 	    NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
299 | 	    
300 | 	    qNAN: String.fromCharCode(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff),
301 | 	    pINF: String.fromCharCode(0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
302 | 	    nINF: String.fromCharCode(0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
303 | 	    zero: String.fromCharCode(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
304 | 	},
305 | 	'float': {
306 | 	    bias: 127,
307 | 	    bytes: 4,
308 | 	    exp: 8,
309 | 	    
310 | 	    POSITIVE_INFINITY: (2 - Math.pow(2, -23)) * Math.pow(2, 127),
311 | 	    NEGATIVE_INFINITY: -(2 - Math.pow(2, -23)) * Math.pow(2, 127),
312 | 	    
313 | 	    qNAN: String.fromCharCode(0xff, 0xff, 0xff, 0xff),
314 | 	    pINF: String.fromCharCode(0x7f, 0x80, 0x00, 0x00),
315 | 	    nINF: String.fromCharCode(0xff, 0x80, 0x00, 0x00),
316 | 	    zero: String.fromCharCode(0x00, 0x00, 0x00, 0x00)
317 | 	}
318 |     }[type || 'double'];
319 |     
320 |     if ( isNaN(val) )  return config.qNAN;
321 |     if ( val >= config.POSITIVE_INFINITY ) return config.pINF;
322 |     if ( val <= config.NEGATIVE_INFINITY ) return config.nINF;
323 |     if ( Math.abs(val) == 0 )  return config.zero;
324 | 
325 |     var zeropadding = function(val,len,prepare) {
326 | 	var padding = "0000000000".substring(0,len-val.length);
327 | 	return prepare ? padding+val : val+padding;
328 |     }
329 |     var bval = Math.abs(val).toString(2);
330 |     var exp = bval.indexOf(".") - 1 + config.bias;
331 |     var bfrac = bval.replace(".", "");
332 |     exp -= bfrac.indexOf("1");
333 |     bfrac = bfrac.substring(bfrac.indexOf("1")+1);
334 |     var bits = (val<0?"1":"0")+zeropadding(exp.toString(2), config.exp, true)+bfrac;
335 | 
336 |     result = [];
337 |     for (var i = 0; i < config.bytes; i++) {
338 | 	result.push(String.fromCharCode(parseInt(zeropadding(bits.substring(i*8,i*8+8),8,false),2)));
339 |     }
340 |     
341 |     return result.reverse().join("");
342 | };
343 | 
344 | 
345 | var decodeIEEE754 = function(data) {
346 |     var bits = data.split('').map(function(s){return s.charCodeAt(0);}).reverse();
347 |     var n = bits.length;
348 |     var config = {
349 | 	4: {
350 | 	    bias: 127,
351 | 	    sgnd: 23,
352 | 	    pbias: Math.pow(2, 126),
353 | 	    psgnd: Math.pow(2, 23)
354 | 	},
355 | 	8: {
356 | 	    bias: 1023,
357 | 	    sgnd: 52,
358 | 	    pbias: Math.pow(2, 1022),
359 | 	    psgnd: Math.pow(2, 52)
360 | 	}
361 |     }[n];
362 | 
363 |     var e, m;
364 |     if ( n == 4 ) {
365 |         e = ((bits[0] & 0x7f) << 1) + (bits[1] >> 7);
366 |         m = bits[1] & 0x7f;
367 |     }
368 |     else if ( n == 8 ) {
369 |         e = ((bits[0] & 0x7f) << 4) + (bits[1] >> 4);
370 |         m = bits[1] & 0x0f;
371 |     }
372 |     else {
373 |         throw "Range error";
374 |     }
375 | 
376 |     s = bits[0] & 0x80;
377 |     for (var i = 2; i < n; i++) {
378 |         m = m * 0x100 + bits[i];
379 |     }
380 | 
381 |     // e = 0xff, 0x7ff - +INF, -INF or NAN
382 |     if ( e == config.bias * 2 + 1 ) {
383 |         // NAN
384 |         if ( m ) {
385 |             return 0 / 0;
386 |         }
387 | 
388 |         // +INF, -INF
389 |         return (s ? -1 : +1) / 0;
390 |     }
391 | 
392 |     var result = e 
393 |         ? (m / config.psgnd + 1) * Math.pow(2, e - config.bias) 
394 |         : m / config.psgnd / config.pbias;
395 |     
396 |     return s ? -result : result;
397 | };
398 | 
399 | /*
400 | node-mysql
401 | A node.js interface for MySQL
402 | 
403 | Author: masuidrive <masui@masuidrive.jp>
404 | License: MIT License
405 | Copyright (c) Yuichiro MASUI
406 | */
407 | 
408 | // pack/unpack Original
409 | // MIT license http://phpjs.org/functions/pack:880
410 | // http://kevin.vanzonneveld.net
411 | // +   original by: Tim de Koning (http://www.kingsquare.nl)
412 | // +      parts by: Jonas Raoni Soares Silva
413 | // +      http://www.jsfromhell.com    // %        note 1: Float encoding by: Jonas Raoni Soares Silva
414 | 
415 | // encode/decodeFloat Original
416 | // http://snippets.dzone.com/posts/show/685


--------------------------------------------------------------------------------
/lib/mysql/packet.js:
--------------------------------------------------------------------------------
  1 | var sys = require('sys');
  2 | var pack = require('./pack');
  3 | var constants = require('./constants');
  4 | var utils = require('./utils');
  5 | var types = require('./types');
  6 | var Charset = require('./charset').Charset;
  7 | var Promise = require('./node-promise').Promise;
  8 | 
  9 | // convert Numeric to LengthCodedBinary
 10 | var lcb = function(num) {
 11 |     if(num==undefined) return "\xfb";
 12 |     if(num<251) return pack.pack("C", num);
 13 |     if(num<65536) return pack.pack("Cv", 252, num);
 14 |     if(num<16777216) return pack.pack("CvC", 253, num&0xffff, num>>16);
 15 |     return pack.pack("CVV", 254, num&0xffffffff, num>>32);
 16 | }
 17 | 
 18 | /* convert LengthCodedBinary to Integer
 19 | # === Argument
 20 | # lcb :: [String] LengthCodedBinary. This value will be broken.
 21 | # === Return
 22 | # Integer or nil */
 23 | var lcb2int = function(lcbs) {
 24 |     if(!lcbs[0]) return undefined;
 25 |     
 26 |     var ret;
 27 |     var lcb = lcbs[0];
 28 |     var v = lcb.substring(0,1);
 29 |     lcb = lcb.slice(1);
 30 |     switch(v) {
 31 |     case "\xfb":
 32 | 	v = undefined;
 33 | 	break;
 34 | 	
 35 |     case "\xfc":
 36 | 	v = pack.unpack("v", lcb.substring(0,2))[0];
 37 | 	lcb = lcb.slice(2);
 38 | 	break;
 39 | 	
 40 |     case "\xfd":
 41 | 	v = pack.unpack("Cv", lcb.substring(0,3));
 42 | 	lcb = lcb.slice(3);
 43 | 	v = (v[1]<<8)+v[0];
 44 | 	break;
 45 | 	
 46 |     case "\xfe":
 47 | 	v = pack.unpack("VV", lcb.substring(0,8));
 48 | 	lcb = lcb.slice(8);
 49 | 	v = (v[1]<<32)+v[0];
 50 | 	break;
 51 | 	
 52 |     default:
 53 | 	v =  v.charCodeAt(0);
 54 | 	break;
 55 |     }
 56 |     lcbs[0] = lcb;
 57 |     return(v);
 58 | }
 59 | 
 60 | var lcs = function(str) {
 61 |     return lcb(str.length)+str;
 62 | }
 63 | 
 64 | var lcs2str = function(lcs) {
 65 |     var len = lcb2int(lcs);
 66 |     if(typeof(len)=="undefined") return undefined;
 67 |     var data = lcs[0].substring(0, len);
 68 |     lcs[0] = lcs[0].slice(len);
 69 |     return data;
 70 | }
 71 | exports.lcs2str = lcs2str;
 72 | 
 73 | var net2value = function(adata, field, charset) {
 74 |     var unsigned = !!(field.flags & constants.field.UNSIGNED_FLAG);
 75 |     var binary = !!(field.flags & constants.field.BINARY_FLAG);
 76 |     var type = field.type;
 77 |     
 78 |     switch(type.id) {
 79 |     case constants.field.TYPE_BLOB:
 80 |     case constants.field.TYPE_STRING:
 81 |     case constants.field.TYPE_VAR_STRING:
 82 |     case constants.field.TYPE_NEWDECIMAL:
 83 | 	if(binary) {
 84 |             return lcs2str(adata);
 85 | 	}
 86 | 	else {
 87 |             return charset.convertFromBytes(lcs2str(adata));
 88 | 	}
 89 |     case constants.field.TYPE_TINY:
 90 | 	var data = adata[0].substring(0, 1);
 91 | 	adata[0] = adata[0].substring(1);
 92 |         var v = pack.unpack("C", data)[0]
 93 |         return unsigned ? v : v < (256)/2 ? v : v-(256);
 94 | 	
 95 |     case constants.field.TYPE_SHORT:
 96 | 	var data = adata[0].substring(0, 2);
 97 | 	adata[0] = adata[0].substring(2);
 98 |         var v = pack.unpack("v", data)[0]
 99 |         return unsigned ? v : v < (65536)/2 ? v : v-(65536);
100 |     
101 |     case constants.field.TYPE_INT24:
102 |     case constants.field.TYPE_LONG:
103 | 	var data = adata[0].substring(0, 4);
104 | 	adata[0] = adata[0].substring(4);
105 |         var v = pack.unpack("V", data)[0]
106 |         return unsigned ? v : v < (4294967296)/2 ? v : v-(4294967296);
107 |     
108 |     case constants.field.TYPE_LONGLONG:
109 | 	var data = adata[0].substring(0, 8);
110 | 	adata[0] = adata[0].substring(8);
111 |         var n = pack.unpack("VV", data)
112 |         var v = (n[1] << 32) | n[0];
113 |         return unsigned ? v : v < (18446744073709551616)/2 ? v : v-(18446744073709551616);
114 |     
115 |     case constants.field.TYPE_FLOAT:
116 | 	var data = adata[0].substring(0, 4);
117 | 	adata[0] = adata[0].substring(4);
118 |         return pack.unpack("e", data)[0]
119 |     
120 |     case constants.field.TYPE_DOUBLE:
121 | 	var data = adata[0].substring(0, 8);
122 | 	adata[0] = adata[0].substring(8);
123 |         return pack.unpack("E", data)[0]
124 | 	
125 |     case constants.field.TYPE_DATE:
126 |     case constants.field.TYPE_DATETIME:
127 |     case constants.field.TYPE_TIMESTAMP:
128 | 	var len = adata[0].charCodeAt(0);
129 | 	var data = adata[0].substring(1, len+1+1);
130 | 	adata[0] = adata[0].substring(len+1+1);
131 |         var ret = pack.unpack("vCCCCCV", data);
132 | 	return new types.Time(ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6]);
133 |     
134 |     case constants.field.TYPE_TIME:
135 | 	var len = adata[0].charCodeAt(0);
136 | 	var data = adata[0].substring(1, len+1+1);
137 | 	adata[0] = adata[0].substring(len+1+1);
138 |         var ret = pack.unpack("CVCCCV", data);
139 | 	return new types.Time(0, 0, 0, ret[1]*24+ret[2], ret[3], ret[4], ret[0]!=0, ret[5]);
140 | 	
141 |     case constants.field.TYPE_YEAR:
142 | 	var data = adata[0].substring(0, 2);
143 | 	adata[0] = adata[0].substring(2);
144 | 	return pack.unpack("v", data)[0];
145 |     
146 |     case constants.field.TYPE_BIT:
147 |         return lcs2str(adata);
148 | 
149 |     default:
150 |         throw "not implemented: type="+type;
151 |     }
152 | }
153 | 
154 | var value2net = function(v, charset) {
155 |     var val = '', type=0;
156 |     switch(typeof(v)) {
157 |     case 'undefined':
158 |         type = constants.field.TYPE_NULL;
159 |         val = "";
160 | 	break;
161 | 
162 |     case 'number':
163 | 	if(parseInt(v)==v) { // is integer
164 |             if(v >= 0) {
165 | 		if(v < 256) {
166 | 		    type = constants.field.TYPE_TINY | 0x8000;
167 | 		    val = pack.pack("C", v);
168 | 		}
169 | 		else if(v < 256*256) {
170 | 		    type = constants.field.TYPE_SHORT | 0x8000;
171 | 		    val = pack.pack("v", v);
172 | 		}
173 | 		else if(v < 256*256*256*256) {
174 | 		    type = constants.field.TYPE_LONG | 0x8000;
175 | 		    val = pack.pack("V", v);
176 | 		}
177 | 		else if(v < 256*256*256*256*256*256*256*256) {
178 | 		    type = constants.field.TYPE_LONGLONG | 0x8000
179 | 		    val = pack.pack("VV", v&0xffffffff, v>>32);
180 | 		}
181 | 		else {
182 | 		   throw "value too large: "+v;
183 | 		}
184 | 	    }
185 |             else {
186 | 		if(-1*v <= 256/2) {
187 | 		    type = constants.field.TYPE_TINY;
188 | 		    val = pack.pack("C", v);
189 | 		}
190 | 		else if(-1*v <= (256*256)/2) {
191 | 		    type = constants.field.TYPE_SHORT;
192 | 		    val = pack.pack("v", v);
193 | 		}
194 | 		else if(-1*v <= (256*256*256*256)/2) {
195 | 		    type = constants.field.TYPE_LONG;
196 | 		    val = pack.pack("V", v);
197 | 		}
198 | 		else if(-1*v <= (256*256*256*256*256*256*256*256)/2) {
199 | 		    type = constants.field.TYPE_LONGLONG;
200 | 		    val = pack.pack("VV", v&0xffffffff, v>>32);
201 | 		}
202 | 		else {
203 | 		    throw "value too large: "+v;
204 | 		}
205 | 	    }
206 |         }
207 | 	else { // is double
208 |             type = constants.field.TYPE_DOUBLE;
209 |             val = pack.pack("E", v);
210 | 	}
211 |         break;
212 | 	
213 |     case 'string':
214 |         type = constants.field.TYPE_STRING;
215 |         val = lcs(charset.convertToBytes(v));
216 | 	break;
217 | 	
218 |     case 'object':
219 | 	if(v.constructor.toString().indexOf(" Date(")) {
220 |             type = constants.field.TYPE_DATETIME;
221 | 	    val = pack.pack("CvCCCCC", 7, v.year, v.month, v.day, v.hour, v.minute, v.second);
222 | 	}
223 | 	else if(v.year || v.month || v.day || v.hour || v.minute || v.second) {
224 |             type = constants.field.TYPE_DATETIME;
225 | 	    val = pack.pack("CvCCCCC", 7, v.year, v.month, v.day, v.hour, v.minute, v.second);
226 | 	}
227 | 	else {
228 | 	    throw "class: "+v+" is not supported";
229 | 	}
230 | 	break;
231 | 	
232 |     default:
233 | 	throw "class: "+v+" is not supported";
234 |     }
235 |     return [type, val];
236 | }
237 | 
238 | 
239 | exports.InitialPacket = function(data) {
240 |     res = pack.unpack("Ca*Va8CvCva13a13", data);
241 |     
242 |     this.protocol_version = res[0];     // C
243 |     this.server_version = res[1];       // a*
244 |     this.thread_id = res[2];            // V
245 |     this.scramble_buff = res[3]+res[9]; // a8 + a13
246 |     this.server_capabilities = res[5];  // v
247 |     this.server_charset = res[6];       // C
248 |     this.server_status = res[7];        // v
249 | };
250 | 
251 | exports.AuthenticationPacket = function(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename) {
252 |     return(pack.pack("VVca23a*A*a*", 
253 |         client_flags,
254 |         max_packet_size,
255 |         charset_number,
256 |         "",                   // always 0x00 * 23
257 |         username,
258 |         lcs(scrambled_password),
259 |         databasename || ''
260 |     ));
261 | };
262 | 
263 | 
264 | // Field packet
265 | var FieldPacket = function(db, table, org_table, name, org_name, charsetnr, length, type, flags, decimals, defaultVal) {
266 |     this.db = db;
267 |     this.table = table;
268 |     this.org_table = org_table;
269 |     this.name = name;
270 |     this.org_name = org_name;
271 |     this.charsetnr = charsetnr;
272 |     this.length = length;
273 |     this.type = types.Types[type];
274 |     this.flags = flags;
275 |     this.decimals = decimals;
276 |     this.defaultVal = defaultVal;
277 | }
278 | exports.FieldPacket = FieldPacket;
279 | 
280 | FieldPacket.parse = function(data) {
281 |     var adata = [data];
282 | 
283 |     var first = lcs2str(adata);
284 |     var db = lcs2str(adata);
285 |     var table = lcs2str(adata);
286 |     var org_table = lcs2str(adata);
287 |     var name = lcs2str(adata);
288 |     var org_name = lcs2str(adata);
289 | 
290 |     var more = pack.unpack("CvVCvCva*", adata[0]);
291 |     if(more[6]!=0) return undefined;
292 |     // raise ProtocolError, "invalid packet: f1="+etc[0]+"" unless etc[0] == 0
293 |     var defaultVal = lcs2str([more[7]]);
294 |     return new FieldPacket(db, table, org_table, name, org_name, more[1], more[2], more[3], more[4], more[5], defaultVal);
295 | }
296 | 
297 | 
298 | var ResultPacket = function(field_count, affected_rows, insert_id, server_status, warning_count, message) {
299 |     this.field_count = field_count;
300 |     this.affected_rows = affected_rows;
301 |     this.insert_id = insert_id;
302 |     this.server_status = server_status;
303 |     this.warning_count = warning_count;
304 |     this.message = message;
305 | }
306 | exports.ResultPacket = ResultPacket;
307 | 
308 | ResultPacket.parse = function(data) {
309 |     var adata = [data];
310 |     var field_count = lcb2int(adata);
311 |     
312 |     if(field_count == 0) {
313 |         var affected_rows = lcb2int(adata);
314 |         var insert_id = lcb2int(adata);
315 | 	var ret = pack.unpack("vva*", adata[0]);
316 |         var server_status = ret[0];
317 | 	var warning_count = ret[1];
318 | 	var message = lcs2str([ret[2]]);
319 | 	return(new ResultPacket(field_count, affected_rows, insert_id, server_status, warning_count, message));
320 |     }
321 |     else if(typeof(field_count)=='undefined') {
322 | 	return(new ResultPacket(undefined, undefined, undefined, undefined, undefined, adata[0]));
323 |     }
324 |     return(new ResultPacket(field_count))
325 | }
326 | 
327 | 
328 | var PrepareResultPacket = function(statement_id, field_count, param_count, warning_count) {
329 |     this.statement_id = statement_id;
330 |     this.field_count = field_count;
331 |     this.param_count = param_count;
332 |     this.warning_count = warning_count;
333 | }
334 | exports.PrepareResultPacket = PrepareResultPacket;
335 | 
336 | PrepareResultPacket.parse = function(data) {
337 |     var res = pack.unpack("cVvvCv", data);
338 |     if(res[0]!=0 || res[4]!=0) throw("invalid packet");
339 |     return new PrepareResultPacket(res[1], res[2], res[3], res[5]);
340 | }
341 | 
342 | var ExecutePacket = {}
343 | exports.ExecutePacket = ExecutePacket;
344 | 
345 | ExecutePacket.serialize = function(statement_id, cursor_type, values, charset) {
346 |     var nbm = null_bitmap(values);
347 |     var netvalues = "";
348 |     var types = values.map(function(v) {
349 |         var ret = value2net(v, charset);
350 |         if(typeof(v)!='undefined') {
351 | 	    netvalues = netvalues.concat(ret[1]);
352 | 	}
353 |         return ret[0];
354 |     });
355 |     
356 |     return pack.pack("CVCVZ*CZ*Z*", constants.com.STMT_EXECUTE, statement_id, cursor_type, 1, nbm, 1, pack.pack("v*", types), netvalues);
357 | }
358 | 
359 | // make null bitmap
360 | // If values is [1, nil, 2, 3, nil] then returns "\x12"(0b10010).
361 | var null_bitmap = function(values) {  
362 |     var val=0, len=0, bitmap=[];
363 |     values.map(function(v) {
364 | 	val += (typeof(v)=="undefined" ? 1<<len : 0);
365 | 	len += 1;
366 | 	if(len==8) {
367 | 	    bitmap.push(val);
368 | 	    len = val = 0;
369 | 	}
370 | 	return val;
371 |     });
372 |     if(len>0) {
373 | 	bitmap.push(val);
374 |     }
375 |     return pack.pack("C*", bitmap);
376 | }
377 | 
378 | // StatementRecord packet
379 | var StatementRecordPacket = function(){
380 | }
381 | exports.StatementRecordPacket = StatementRecordPacket;
382 | 
383 | StatementRecordPacket.parse = function(data, fields, charset) {
384 |     var null_bit_map_len = (fields.length+7+2)/8;
385 |     var null_bit_map = pack.unpack("b*", data.substring(1, null_bit_map_len+1+1))[0];
386 |     var i = -1, v;
387 |     var adata = [data.substring(1+null_bit_map_len)];
388 |     return fields.map(function(field) {
389 | 	i += 1;
390 |         if(null_bit_map.substring(i+2,i+3) == '1') {
391 |             return undefined;
392 |         }
393 | 	else {
394 |             return net2value(adata, field, charset);
395 | 	}
396 |     });
397 | }
398 | 


--------------------------------------------------------------------------------
/lib/mysql/protocol.js:
--------------------------------------------------------------------------------
  1 | // Protocol:
  2 | // MySQL Protocol 
  3 | var sys = require('sys');
  4 | var fs = require("fs");
  5 | var events = require('events');
  6 | var pack = require('./pack');
  7 | var errors = require('./errors');
  8 | var constants = require('./constants');
  9 | var packet = require('./packet');
 10 | var auth = require('./auth');
 11 | var utils = require('./utils');
 12 | var Charset = require('./charset').Charset;
 13 | var Promise = require('./node-promise').Promise;
 14 | var Connection = require('./connection').Connection;
 15 | 
 16 | var Protocol = function(host, port) {
 17 |     events.EventEmitter.call(this);
 18 |     this.state = undefined;
 19 |     this.gc_stmt_queue = [];
 20 |     this.ready_state_queue = [];
 21 |     this.charset = undefined;
 22 |     this.authinfo = undefined;
 23 |     this.server_info = undefined;
 24 |     this.server_version = undefined;
 25 |     this.thread_id = undefined;
 26 |     this.message = undefined;
 27 |     this.affected_rows = undefined;
 28 |     this.insert_id = undefined;
 29 |     this.server_status = undefined;
 30 |     this.warning_count = undefined;
 31 |     this.request_close = false;
 32 | 
 33 |     this.set_state('INIT');
 34 |     this.conn = new Connection(port || 3306, host || 'localhost');
 35 | 
 36 |     this.conn.addListener('connect', utils.scope(this, function() {	
 37 | 	this.emit('connect');
 38 |     }));
 39 |     this.conn.addListener('close', utils.scope(this, function() {	
 40 | 	this.gc_stmt_queue = [];
 41 | 	this.set_state('INIT');
 42 | 	this.emit('close');
 43 |     }));
 44 | 
 45 |     this.conn.connect();
 46 | }
 47 | sys.inherits(Protocol, events.EventEmitter);
 48 | exports.Protocol = Protocol;
 49 | 
 50 | // close TCP session
 51 | Protocol.prototype.close = function() {
 52 |     if(this.state=='INIT' && this.ready_state_queue.length==0) {
 53 | 	this.conn.close();
 54 |     }
 55 |     else {
 56 | 	this.wait_ready_state(undefined, utils.scope(this, function(error) {
 57 | 	    this.conn.close();
 58 | 	}));
 59 |     }
 60 | }
 61 | 
 62 | Protocol.prototype.timeout = function(msec) {
 63 |     if(this.conn) this.conn.timeout(msec);
 64 | }
 65 | 
 66 | Protocol.prototype.gc_stmt = function(stmt_id) {
 67 |     this.gc_stmt_queue.push(stmt_id);
 68 | }
 69 | 
 70 | // authenticate process
 71 | Protocol.prototype.authenticate = function(user, passwd, db, flag, charset_str) {
 72 |     var promise = new Promise();
 73 |     if(!this.check_state('INIT', promise)) return promise;
 74 |     this.authinfo = [user, passwd, db, flag, charset_str];
 75 |     this.conn.reset();
 76 |     this.conn.read()
 77 | 	.addCallback(utils.scope(this, function(buff) {
 78 | 	    var init_packet = new packet.InitialPacket(buff);
 79 | 	    if(init_packet.protocol_version!=10) {
 80 | 		promise.emitError(new errors.ClientError("Don't support protocol version "+init_packet.protocol_version));
 81 | 		this.flush_ready_state(new errors.ClientError("Don't support protocol version "+init_packet.protocol_version));
 82 | 		return;
 83 | 	    }
 84 | 	    this.server_info = init_packet.server_version;
 85 | 	    var i = init_packet.server_version.split(".");
 86 | 	    this.server_version = parseInt(i[0])*100+parseInt(i[1]);
 87 | 	    
 88 | 	    this.thread_id = init_packet.thread_id;
 89 | 	    var client_flags = constants.client.LONG_PASSWORD
 90 | 		| constants.client.LONG_FLAG
 91 | 		| constants.client.TRANSACTIONS
 92 | 		| constants.client.PROTOCOL_41
 93 | 		| constants.client.SECURE_CONNECTION;
 94 | 	    if(db) client_flags |= constants.client.CONNECT_WITH_DB;
 95 | 	    client_flags |= flag;
 96 | 	    
 97 | 	    if(charset_str) {
 98 | 		this.charset = Charset.by_name(charset_str);
 99 | 	    }
100 | 	    else {
101 | 		this.charset = Charset.by_number(init_packet.server_charset);
102 | 	    }
103 | 	    
104 | 	    var netpw = auth.encrypt_password(passwd, init_packet.scramble_buff);
105 | 	    try {
106 | 		this.conn.write(packet.AuthenticationPacket(client_flags, 1024*1024*1024, this.charset.number, user, netpw, db))
107 | 		    .addErrback(utils.scope(this, function(error) {
108 | 			this.emit("authorize error");
109 | 			promise.emitError(error);
110 | 		    }));
111 | 		this.conn.read()
112 | 		    .addCallback(utils.scope(this, function(buff){
113 | 			this.query_command("SET NAMES '"+this.charset.name+"'", true)
114 | 			    .addErrback(utils.scope(this, function(error) {
115 | 				this.emit("authorize error");
116 | 				promise.emitError(error);
117 | 			    }));
118 | 			this.set_state('READY');
119 | 			this.emit("authorized");
120 | 			promise.emitSuccess();
121 | 		    }))
122 | 		    .addErrback(utils.scope(this, function(error) {
123 | 			this.emit("authorize error");
124 | 			promise.emitError(error);
125 | 		    }));
126 | 	    }
127 | 	    catch(e) {
128 | 		promise.emitError(new errors.ClientError(e.message));
129 | 	    }
130 | 	}))
131 | 	.addErrback(utils.scope(this, function(error) {
132 | 	    this.emit("authorize error", new errors.ClientError('authorize error'));
133 | 	    promise.emitError(error);
134 | 	}));
135 |     return promise;
136 | }
137 | 
138 | // send query command
139 | Protocol.prototype.query_command = function(query, immediately) {
140 |     var promise = new Promise();
141 |     
142 |     var err = utils.scope(this, function(error) {
143 | 	this.set_state('READY');
144 | 	promise.emitError(error);
145 |     });
146 |     
147 |     this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
148 | 	if(error) {
149 | 	    this.set_state('READY');
150 | 	    return(promise.emitError(error));
151 | 	}
152 | 	this.conn.reset();
153 | 	this.conn.write(pack.pack("CZ*", constants.com.QUERY, this.charset.convertToBytes(query)))
154 | 	    .addCallback(utils.scope(this, function(buff) {
155 | 		this.get_result()
156 | 		    .addCallback(function(nfields) {
157 | 			promise.emitSuccess(nfields);
158 | 		    })
159 | 		    .addErrback(err);
160 | 	    }))
161 | 	    .addErrback(err);
162 |     }), immediately);
163 |     return promise;
164 | }
165 | 
166 | // read result fields count
167 | Protocol.prototype.get_result = function() {
168 |     var promise = new Promise();
169 | 
170 |     this.conn.read()
171 | 	.addCallback(utils.scope(this, function(buff) {
172 |             var res_packet = packet.ResultPacket.parse(buff);
173 |             this.affected_rows = res_packet.affected_rows;
174 | 	    this.insert_id = res_packet.insert_id;
175 | 	    this.server_status = res_packet.server_status;
176 | 	    this.warning_count = res_packet.warning_count;
177 | 	    this.message = res_packet.message;
178 | 	    
179 |             if(res_packet.field_count>0) {  // result data exists
180 | 		this.set_state('FIELD');
181 | 		promise.emitSuccess(res_packet.field_count);
182 | 	    }
183 |             else if(typeof(res_packet.field_count)=='undefined') {  // LOAD DATA LOCAL INFILE
184 | 		var filename = res_packet.message
185 | 		fs.readFile(filename, 'UTF-8', utils.scope(this, function(err, data) {
186 | 		    if(err) {
187 | 			promise.emitError(new errors.ClientError("Can't read '"+filename+"'"));
188 | 			this.set_state('READY');
189 | 			return;
190 | 		    }
191 | 		    var error_handler = utils.scope(this, function(error) {
192 | 			this.set_state('READY');
193 | 			promise.emitError(error);
194 | 		    });
195 | 		    this.conn.write(data).addErrback(error_handler);
196 | 		    this.conn.write().addErrback(error_handler); // EOF mark
197 | 		    this.conn.read()
198 | 			.addCallback(utils.scope(this, function() {
199 | 			    this.set_state('READY');
200 | 			    promise.emitSuccess(undefined);
201 | 			}))
202 | 			.addErrback(error_handler);
203 | 		}));
204 | 	    }
205 | 	    else { // field_count == 0
206 | 		this.set_state('READY');
207 | 		promise.emitSuccess(undefined);
208 | 	    }
209 | 	}))
210 |         .addErrback(function(error) {
211 | 	    promise.emitError(error);
212 | 	});
213 |     return promise;
214 | }
215 | 
216 | // Set option command
217 | Protocol.prototype.set_option_command = function(opt) {
218 |     return this.simple_command(pack.pack("Cv", constants.com.SET_OPTION, opt));
219 | }
220 | 
221 | // send simple command
222 | Protocol.prototype.simple_command = function(packet) {
223 |     var promise = new Promise();
224 |     
225 |     var err = utils.scope(this, function(error) {
226 | 	this.set_state('READY');
227 | 	promise.emitError(error);
228 |     });
229 |     
230 |     this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
231 | 	if(error) {
232 | 	    this.set_state('READY');
233 | 	    return(promise.emitError(error));
234 | 	}
235 | 	this.conn.reset();
236 | 	this.conn.write(packet)
237 | 	    .addCallback(utils.scope(this, function() {
238 | 		this.conn.read()
239 | 		    .addCallback(utils.scope(this, function() {
240 | 			this.set_state('READY');
241 | 			promise.emitSuccess();
242 | 		    }))
243 | 		    .addErrback(err);
244 | 	    }))
245 | 	    .addErrback(err);
246 |     }));
247 |     return promise;
248 | }
249 | 
250 | // get field info
251 | Protocol.prototype.retr_fields = function(nfields) {
252 |     var promise = new Promise();
253 |     if(!this.check_state('FIELD', promise)) return promise;
254 |     
255 |     var fields = [];
256 |     for(var i=0; i<nfields; ++i) {
257 | 	this.conn.read()
258 | 	    .addCallback(utils.scope(this, function(buff) {
259 | 		fields.push(packet.FieldPacket.parse(buff));
260 | 		if(fields.length>=nfields) {
261 | 		    this.read_eof_packet()
262 | 			.addCallback(utils.scope(this, function(buff) {
263 | 			    this.set_state('RESULT');
264 | 			    promise.emitSuccess(fields);
265 | 			}))
266 | 			.addErrback(utils.scope(function(error) {
267 | 			    this.set_state('READY');
268 | 			    promise.emitError(error);
269 | 			}));
270 | 		}
271 | 	    }))
272 | 	    .addErrback(utils.scope(this, function(error) {
273 | 		this.set_state('READY');
274 | 		promise.emitError(error);
275 | 	    }));
276 |     }
277 |     
278 |     return promise;
279 | }
280 | 
281 | // 
282 | Protocol.prototype.read_eof_packet = function(nfields) {
283 |     var promise = new Promise();
284 |     this.conn.read()
285 | 	.addCallback(utils.scope(this, function(buff) {
286 | 	    if(is_eof_packet(buff)) {
287 | 		promise.emitSuccess();
288 | 	    }
289 | 	    else {
290 | 		promise.emitError(new errors.ProtocolError("packet is not EOF"));
291 | 	    }
292 | 	}))
293 | 	.addErrback(utils.scope(function(error) {
294 | 	    promise.emitError(error);
295 | 	}));
296 |     return promise;
297 | };
298 | 
299 | var is_eof_packet = function(data) {
300 |     return data.substring(0,1)=="\xfe" && data.length==5;
301 | }
302 | 
303 | Protocol.prototype.retr_all_records = function(fields, each_callback, end_callback) {
304 |     var promise = new Promise();
305 |     if(!this.check_state('RESULT', promise)) return promise;
306 |     var get_line = utils.scope(this, function() {
307 | 	this.conn.read()
308 | 	    .addCallback(utils.scope(this, function(data) {
309 | 		if(is_eof_packet(data)) {
310 | 		    this.server_status = data.charCodeAt(3);
311 | 		    this.set_state('READY');
312 | 		    promise.emitSuccess(end_callback());
313 | 		}
314 | 		else {
315 | 		    var rec = [], adata = [data];
316 | 		    for(var i=0; i<fields.length; ++i) {
317 | 			var val = packet.lcs2str(adata);
318 | 			rec.push(fields[i].type.convert(val, this.charset, fields[i]));
319 | 		    }
320 | 		    each_callback(rec);
321 | 		    get_line();
322 | 		}
323 | 	    }))
324 | 	    .addErrback(utils.scope(this, function(error) {
325 | 		this.set_state('READY');
326 | 		promise.emitError(error);
327 |             }));
328 |     });
329 |     get_line();
330 |     return promise;
331 | }
332 | 
333 | Protocol.prototype.stmt_prepare_command = function(stmt) {
334 |     var promise = new Promise();
335 | 
336 |     this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
337 | 	if(error) {
338 | 	    this.set_state('READY');
339 | 	    return(promise.emitError(error));
340 | 	}
341 | 	this.conn.reset();
342 | 	this.conn.write(pack.pack("Ca*", constants.com.STMT_PREPARE, this.charset.convertToBytes(stmt)))
343 | 	    .addErrback(function(error) {
344 | 		promise.emitError(error);
345 | 	    });
346 | 	this.conn.read()
347 |             .addCallback(utils.scope(this, function(buff) {
348 | 		var res_packet = packet.PrepareResultPacket.parse(buff);
349 | 		var func = utils.scope(this, function() {
350 | 		    if(res_packet.field_count > 0) {
351 | 			this.conn.read(res_packet.field_count) // skip parameter packet
352 | 		            .addCallback(utils.scope(this, function(packets) {
353 | 				field_packets = [];
354 | 				for(var i=0; i<res_packet.field_count; ++i) {
355 | 				    field_packets.push(packet.FieldPacket.parse(packets[i]));
356 | 				}
357 | 				this.read_eof_packet()
358 | 				    .addCallback(utils.scope(this, function() {
359 | 					promise.emitSuccess(res_packet.statement_id, res_packet.param_count, field_packets);
360 | 				    }))
361 | 				    .addErrback(function(error) {
362 | 					promise.emitError(error);
363 | 				    });
364 | 			    }))
365 | 			    .addErrback(function(error) {
366 | 				promise.emitError(error);
367 | 			    });
368 | 		    }
369 | 		    else {
370 | 			promise.emitSuccess(res_packet.statement_id, res_packet.param_count, []);
371 | 		    }
372 | 		});
373 | 		if(res_packet.param_count > 0) {
374 | 		    this.conn.read(res_packet.param_count) // skip parameter packet
375 | 		        .addCallback(utils.scope(this, function(){
376 | 			    this.read_eof_packet()
377 | 				.addCallback(utils.scope(this, function() {
378 | 				    func();
379 | 				}));
380 | 			}));
381 | 		}
382 | 		else {
383 | 		    func();
384 | 		}
385 | 	    }))
386 |             .addErrback(function(error) {
387 | 		promise.emitError(error);
388 | 	    });
389 |     }));
390 |     return promise;
391 | }
392 | 
393 | Protocol.prototype.stmt_close_command = function(promise, stmt_id) {
394 |     if(typeof(stmt_id)!='undefined') {
395 | 	this.conn.reset();
396 | 	this.conn.write(pack.pack("CV", constants.com.STMT_CLOSE, stmt_id));
397 |     }
398 | }
399 | 
400 | Protocol.prototype.stmt_execute_command = function(stmt_id, values) {
401 |     var promise = new Promise();
402 |     
403 |     var err = utils.scope(this, function(error) {
404 | 	this.set_state('READY');
405 | 	promise.emitError(error);
406 |     });
407 |     
408 |     this.check_state('READY');
409 |     this.conn.reset();
410 |     this.conn.write(packet.ExecutePacket.serialize(stmt_id, constants.stmt.CURSOR_TYPE_NO_CURSOR, values, this.charset))
411 | 	.addErrback(function(error){ promise.emitError(error); });
412 |     this.get_result()
413 |         .addCallback(function(nfields) {
414 | 	    promise.emitSuccess(nfields);
415 | 	})
416 |         .addErrback(err);
417 |     
418 |     return promise;
419 | }
420 | 
421 | Protocol.prototype.stmt_retr_all_records = function(fields, charset) {
422 |     var promise = new Promise();
423 |     
424 |     this.check_state('RESULT');
425 |     var all_recs = [];
426 |     var err = utils.scope(this, function(error) {
427 | 	this.set_state('READY');
428 | 	promise.emitError(error);
429 |     });
430 |     var func = utils.scope(this, function() {
431 | 	this.conn.read()
432 | 	    .addCallback(utils.scope(this, function(buff) {
433 | 		if(is_eof_packet(buff)) {	
434 | 		    this.set_state('READY');
435 | 		    promise.emitSuccess(all_recs);
436 | 		}
437 | 		else {
438 | 		    all_recs.push(packet.StatementRecordPacket.parse(buff, fields, this.charset));
439 | 		    func();
440 | 		}
441 | 	    }))
442 | 	    .addErrback(err);
443 |     });
444 |     func();
445 |     return promise;
446 | }
447 | 
448 | // set protocol state
449 | Protocol.prototype.set_state = function(state) {
450 |     if(this.state == state) return;
451 |     this.state = state;
452 |     if(state=='READY') {
453 | 	while(st = this.gc_stmt_queue.shift()) {
454 | 	    this.stmt_close_command(st);
455 | 	}
456 | 	if(this.ready_state_queue.length>0) {
457 | 	    var task = this.ready_state_queue.shift();
458 | 	    if(task[0]) this.set_state(task[0]);
459 | 	    process.nextTick(task[1]);
460 | 	}
461 |     }
462 | }
463 | 
464 | // check protocol state
465 | Protocol.prototype.check_state = function(st, promise) {
466 |     if(this.state==st) {
467 | 	return true;
468 |     }
469 |     else {
470 | 	if(promise) promise.emitError(new errors.ProtocolError("Unmatch protocol state "+st+"(expect) != "+this.state));
471 | 	return false;
472 |     }
473 | }
474 | 
475 | // wait changing to state
476 | Protocol.prototype.wait_ready_state = function(state, callback, immediately) {
477 |     if(immediately) {
478 | 	this.ready_state_queue.unshift([state, callback]);
479 |     }
480 |     else {
481 | 	this.ready_state_queue.push([state, callback]);
482 |     }
483 |     if(this.state=='READY') {
484 | 	var task = this.ready_state_queue.shift();
485 | 	if(task[0]) this.set_state(task[0]);
486 | 	process.nextTick(task[1]);
487 |     }
488 | }
489 | 
490 | Protocol.prototype.flush_ready_state = function(error) {
491 |     var task;
492 |     while(task = this.ready_state_queue.shift()) {
493 | 	if(task[0]) this.set_state(task[0]);
494 | 	task[1](error);
495 |     }
496 | }
497 | 
498 | /*
499 | node-mysql
500 | A node.js interface for MySQL
501 | 
502 | Author: masuidrive <masui@masuidrive.jp>
503 | License: MIT License
504 | Copyright (c) Yuichiro MASUI
505 | 
506 | # Original:
507 | # http://github.com/tmtm/ruby-mysql
508 | # Copyright (C) 2009-2010 TOMITA Masahiro
509 | # mailto:tommy@tmtm.org
510 | # License: Ruby's
511 | */
512 | 


--------------------------------------------------------------------------------
/lib/mysql/result.js:
--------------------------------------------------------------------------------
 1 | // Result:
 2 | // Result set
 3 | var sys = require('sys');
 4 | var utils = require('./utils');
 5 | 
 6 | // Result set
 7 | var ResultBase = function(fields) {
 8 |     this.fields = fields;
 9 |     this.records = [];
10 |     this.fieldname_with_table = false;
11 | }
12 | exports.ResultBase = ResultBase;
13 | 
14 | 
15 | var Result = function(fields, protocol) {
16 |     ResultBase.call(this, fields);
17 |     this.protocol = protocol;
18 | }
19 | sys.inherits(Result, ResultBase);
20 | exports.Result = Result;
21 | 
22 | Result.prototype.fetch_all = function() {
23 |     var promise = this.protocol.retr_all_records(this.fields,
24 | 	utils.scope(this, function(rec) { // each
25 |             this.records.push(rec);
26 | 	}),
27 | 	utils.scope(this, function() {    // result
28 | 	    return this;
29 | 	}));
30 |     return promise;
31 | }
32 | 
33 | Result.prototype.toHash = function(row) {
34 |     var result, name, field;
35 |     result = {};
36 |     for(var i = 0; i<this.fields.length; ++i) {
37 | 	field = this.fields[i];
38 | 	name = ((this.fieldname_with_table && field.table) ? (field.table+".") : "") + field.name;
39 | 	result[name] = row[i];
40 |     }
41 |     return result;
42 | }
43 | 
44 | 
45 | var StatementResult = function(fields, protocol) {
46 |     ResultBase.call(this, fields);
47 |     this.protocol = protocol;
48 | }
49 | sys.inherits(StatementResult, ResultBase);
50 | exports.StatementResult = Result;
51 | 
52 | 
53 | /*
54 | node-mysql
55 | A node.js interface for MySQL
56 | 
57 | Author: masuidrive <masui@masuidrive.jp>
58 | License: MIT License
59 | Copyright (c) Yuichiro MASUI
60 | 
61 | # Original:
62 | # http://github.com/tmtm/ruby-mysql
63 | # Copyright (C) 2009-2010 TOMITA Masahiro
64 | # mailto:tommy@tmtm.org
65 | # License: Ruby's
66 | */
67 | 


--------------------------------------------------------------------------------
/lib/mysql/sha1.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The JavaScript implementation of the Secure Hash Algorithm 1
  3 |  *
  4 |  *   Copyright (c) 2008  Takanori Ishikawa  <takanori.ishikawa@gmail.com>
  5 |  *   All rights reserved.
  6 |  *
  7 |  *   Redistribution and use in source and binary forms, with or without
  8 |  *   modification, are permitted provided that the following conditions
  9 |  *   are met:
 10 |  * 
 11 |  *   1. Redistributions of source code must retain the above copyright
 12 |  *      notice, this list of conditions and the following disclaimer.
 13 |  *
 14 |  *   2. Redistributions in binary form must reproduce the above copyright
 15 |  *      notice, this list of conditions and the following disclaimer in the
 16 |  *      documentation and/or other materials provided with the distribution.
 17 |  *
 18 |  *   3. Neither the name of the authors nor the names of its contributors
 19 |  *      may be used to endorse or promote products derived from this
 20 |  *      software without specific prior written permission.
 21 |  *
 22 |  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 23 |  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 24 |  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 25 |  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 26 |  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 27 |  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 28 |  *   TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 29 |  *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 30 |  *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 31 |  *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 32 |  *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 33 |  */
 34 | /**
 35 |  * This is the javascript file for code which implements
 36 |  * the Secure Hash Algorithm 1 as defined in FIPS 180-1 published April 17, 1995.
 37 |  *
 38 |  *   Author: Takanori Ishikawa <takanori.ishikawa@gmail.com>
 39 |  *   Copyright: Takanori Ishikawa 2008
 40 |  *   License: BSD License (see above)
 41 |  *
 42 |  * NOTE:
 43 |  *   Only 8-bit string is supported, please use encodeURIComponent() function 
 44 |  *   if you want to hash multibyte string.
 45 |  *
 46 |  * Supported Browsers:
 47 |  *   [Win] IE 6, Firefox 2
 48 |  *   [Mac] Safari 3, Firefox 2
 49 |  *
 50 |  * Usage:
 51 |  *   var hexdigest = new SHA1("Hello.").hexdigest(); // "9b56d519ccd9e1e5b2a725e186184cdc68de0731"
 52 |  *
 53 |  * See Also:
 54 |  *   FIPS 180-1 - Secure Hash Standard
 55 |  *   http://www.itl.nist.gov/fipspubs/fip180-1.htm
 56 |  *
 57 |  */
 58 | 
 59 | var SHA1 = (function(){
 60 | 
 61 |   /**
 62 |    * Spec is the BDD style test utilities.
 63 |    */
 64 |   var Spec = {
 65 |     /** Replace the Spec.describe function with empty function if false. */
 66 |     enabled: true,
 67 |     
 68 |     /** Indicates whether object 'a' is "equal to" 'b'. */
 69 |     equals: function(a, b) {
 70 |       if (a instanceof Array && b instanceof Array) {
 71 |         if (a.length != b.length) return false;
 72 |         for (var i = 0; i < a.length; i++) if (!Spec.equals(a[i], b[i])) return false;
 73 |         return true;
 74 |       }
 75 |       if ((a != null && b != null) && (typeof a == "object" && typeof b == "object")) {
 76 |         for (var i in a) if (!Spec.equals(a[i], b[i])) return false;
 77 |         return true;
 78 |       }
 79 |       return (a == b);
 80 |     },
 81 |     
 82 |     /** equivalent to xUint's assert */
 83 |     should: function(expection, message) {
 84 |       Spec.currentIndicator++;
 85 |       if (!expection) {
 86 |         var warning = [
 87 |           "[Spec failed",
 88 |           Spec.currentTitle ? " (" + Spec.currentTitle + ")] " : "] ",
 89 |           (message || (Spec.currentMessage + " " + Spec.currentIndicator) || "")
 90 |         ].join("");
 91 |         
 92 |         alert(warning);
 93 |         throw warning;
 94 |       }
 95 |       return !!expection;
 96 |     },
 97 |     
 98 |     /** Write your specification by using describe method. */
 99 |     describe: function(title, spec) {
100 |       Spec.currentTitle = title;
101 |       for (var name in spec) {
102 |         Spec.currentMessage = name;
103 |         Spec.currentIndicator = 0;
104 |         spec[name]();
105 |         Spec.currentIndicator = null;
106 |       }
107 |       Spec.currentMessage = Spec.currentTitle = null;
108 |     },
109 |     Version: "0.1"
110 |   };
111 |   
112 |   // Other BDD style stuffs.
113 |   Spec.should.equal = function(a, b, message) { return Spec.should(Spec.equals(a, b), message); };
114 |   Spec.should.not = function(a, message) { return Spec.should(!a, message); };
115 |   Spec.should.not.equal = function(a, b, message) { return Spec.should(!Spec.equals(a, b), message); };
116 |   if (!Spec.enabled) Spec.describe = function(){};
117 |   
118 |   
119 |   // self test
120 |   Spec.describe("Spec object", {
121 |     "should": function() {
122 |       Spec.should(true);
123 |       Spec.should(1);
124 |     }, 
125 |     "should.not": function() {
126 |       Spec.should.not(false);
127 |       Spec.should.not(0);
128 |     },
129 |     "should.equal": function() {
130 |       Spec.should.equal(null, null);
131 |       Spec.should.equal("", "");
132 |       Spec.should.equal(12345, 12345);
133 |       Spec.should.equal([0,1,2], [0,1,2]);
134 |       Spec.should.equal([0,1,[0,1,2]], [0,1,[0,1,2]]);
135 |       Spec.should.equal({}, {});
136 |       Spec.should.equal({x:1}, {x:1});
137 |       Spec.should.equal({x:[1]}, {x:[1]});
138 |     },
139 |     "should.not.equal": function() {
140 |       Spec.should.not.equal([1,2,3], [1,2,3,4]);
141 |       Spec.should.not.equal({x:1}, [1,2,3,4]);
142 |     }
143 |   });
144 | 
145 | 
146 |   // -----------------------------------------------------------
147 |   // Utilities
148 |   // -----------------------------------------------------------
149 |   // int32 -> hexdigits string (e.g. 0x123 -> '00000123')
150 |   function strfhex32(i32) {
151 |     i32 &= 0xffffffff;
152 |     if (i32 < 0) i32 += 0x100000000;
153 |     var hex = Number(i32).toString(16);
154 |     if (hex.length < 8) hex = "00000000".substr(0, 8 - hex.length) + hex;
155 |     return hex;
156 |   }
157 |   Spec.describe("sha1", {
158 |     "strfhex32": function() {
159 |       Spec.should.equal(strfhex32(0x0),          "00000000");
160 |       Spec.should.equal(strfhex32(0x123),        "00000123");
161 |       Spec.should.equal(strfhex32(0xffffffff),   "ffffffff");
162 |     }
163 |   });
164 | 
165 |   // int32 -> string (e.g. 123 -> '00000000 00000000 00000000 01111011')
166 |   function strfbits(i32) {
167 |     if (typeof arguments.callee.ZERO32 == 'undefined') {
168 |       arguments.callee.ZERO32 = new Array(33).join("0");
169 |     }
170 |     
171 |     var bits = Number(i32).toString(2);
172 |     // '0' padding 
173 |     if (bits.length < 32) bits = arguments.callee.ZERO32.substr(0, 32 - bits.length) + bits;
174 |     // split by 8 bits
175 |     return bits.replace(/(\d{8})/g, '$1 ')
176 |                .replace(/^\s*(.*?)\s*$/, '$1');
177 |   }
178 |   Spec.describe("sha1", {
179 |     "strfbits": function() {
180 |       Spec.should.equal(strfbits(0),   "00000000 00000000 00000000 00000000");
181 |       Spec.should.equal(strfbits(1),   "00000000 00000000 00000000 00000001");
182 |       Spec.should.equal(strfbits(123), "00000000 00000000 00000000 01111011");
183 |     }
184 |   });
185 | 
186 | 
187 |   // -----------------------------------------------------------
188 |   // SHA-1
189 |   // -----------------------------------------------------------
190 |   // Returns Number(32bit unsigned integer) array size to fit for blocks (512-bit strings)
191 |   function padding_size(nbits) {
192 |     var n = nbits + 1 + 64
193 |     return 512 * Math.ceil(n / 512) / 32;
194 |   }
195 |   Spec.describe("sha1", {
196 |     "padding_size": function() {
197 |       Spec.should.equal(padding_size(0),             16);
198 |       Spec.should.equal(padding_size(1),             16);
199 |       Spec.should.equal(padding_size(512 - 64 - 1),  16);
200 |       Spec.should.equal(padding_size(512 - 64),      32);
201 |     }
202 |   });
203 | 
204 |   // 8bit string -> uint32[]
205 |   function word_array(m) {
206 |     var nchar = m.length;
207 |     var size = padding_size(nchar * 8);
208 |     var words = new Array(size);
209 |     for (var i = 0, j = 0; i < nchar; ) {
210 |       words[j++] = ((m.charCodeAt(i++) & 0xff) << 24) | 
211 |                    ((m.charCodeAt(i++) & 0xff) << 16) | 
212 |                    ((m.charCodeAt(i++) & 0xff) << 8)  | 
213 |                    ((m.charCodeAt(i++) & 0xff))
214 |     }
215 |     while (j < size) words[j++] = 0;
216 |     return words;
217 |   }
218 |   Spec.describe("sha1", {
219 |     "word_array": function() {
220 |       Spec.should.equal(word_array(""), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
221 |       Spec.should.equal(word_array("1234")[0], 0x31323334);
222 |     }
223 |   });
224 | 
225 |   function write_nbits(words, length, nbits) {
226 |     if (nbits > 0xffffffff) {
227 |       var lo = nbits & 0xffffffff;
228 |       if (lo < 0) lo += 0x100000000;
229 |       words[length - 1] = lo;
230 |       words[length - 2] = (nbits - lo) / 0x100000000;
231 |     } else {
232 |       words[length - 1] = nbits;
233 |       words[length - 2] = 0x0;
234 |     }
235 |     return words;
236 |   }
237 |   Spec.describe("sha1", {
238 |     "write_nbits": function() {
239 |       Spec.should.equal(write_nbits([0, 0], 2, 1),             [0, 1]);
240 |       Spec.should.equal(write_nbits([0, 0], 2, 0xffffffff),    [0, 0xffffffff]);
241 |       Spec.should.equal(write_nbits([0, 0], 2, 0x100000000),   [1, 0]);
242 |       Spec.should.equal(write_nbits([0, 0], 2, 0x1ffffffff),   [1, 0xffffffff]);
243 |       Spec.should.equal(write_nbits([0, 0], 2, 0x12300000000), [0x123, 0]);
244 |       Spec.should.equal(write_nbits([0, 0], 2, 0x123abcdef12), [0x123, 0xabcdef12]);
245 |     }
246 |   });
247 | 
248 |   function padding(words, nbits) {
249 |     var i = Math.floor(nbits / 32);
250 |     
251 |     words[i] |= (1 << (((i + 1) * 32) - nbits - 1));
252 |     write_nbits(words, padding_size(nbits), nbits);
253 |     return words;
254 |   }
255 | 
256 |   function digest(words) {
257 |     var i = 0, t = 0;
258 |     var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
259 |     
260 |     while (i < words.length) {
261 |       var W = new Array(80);
262 |       
263 |       // (a)
264 |       for (t = 0;  t < 16; t++) W[t] = words[i++];
265 |       
266 |       // (b)
267 |       for (t = 16; t < 80; t++) {
268 |         var w = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16];
269 |         W[t] = (w << 1) | (w >>> 31);
270 |       }
271 |       
272 |       // (c)
273 |       var A = H[0], B = H[1], C = H[2], D = H[3], E = H[4];
274 |       
275 |       // (d) TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;
276 |       //     E = D; D = C; C = S30(B); B = A; A = TEMP;
277 |       for (t = 0; t < 80; t++) {
278 |         var tmp = ((A << 5) | (A >>> 27)) + E + W[t];
279 |         
280 |         if      (t >=  0 && t <= 19) tmp += ((B & C) | ((~B) & D))        + 0x5a827999;
281 |         else if (t >= 20 && t <= 39) tmp += (B ^ C ^ D)                   + 0x6ed9eba1;
282 |         else if (t >= 40 && t <= 59) tmp += ((B & C) | (B & D) | (C & D)) + 0x8f1bbcdc;
283 |         else if (t >= 60 && t <= 79) tmp += (B ^ C ^ D)                   + 0xca62c1d6;
284 |         
285 |         E = D; D = C; C = ((B << 30) | (B >>> 2)); B = A; A = tmp;
286 |       }
287 |       
288 |       // (e) H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
289 |       H[0] = (H[0] + A) & 0xffffffff;
290 |       H[1] = (H[1] + B) & 0xffffffff;
291 |       H[2] = (H[2] + C) & 0xffffffff;
292 |       H[3] = (H[3] + D) & 0xffffffff;
293 |       H[4] = (H[4] + E) & 0xffffffff;
294 |       if (H[0] < 0) H[0] += 0x100000000;
295 |       if (H[1] < 0) H[1] += 0x100000000;
296 |       if (H[2] < 0) H[2] += 0x100000000;
297 |       if (H[3] < 0) H[3] += 0x100000000;
298 |       if (H[4] < 0) H[4] += 0x100000000;
299 |     }
300 |     
301 |     return H;
302 |   }
303 | 
304 |   // message: 8bit string
305 |   var SHA1 = function(message) {
306 |     this.message = message;
307 |   }
308 | 
309 |   SHA1.prototype = {
310 |     digest: function() {
311 |       var nbits = this.message.length * 8;
312 |       var words = padding(word_array(this.message), nbits);
313 |       return digest(words);
314 |     },
315 | 
316 |     hexdigest: function() {
317 |       var digest = this.digest();
318 |       for (var i = 0; i < digest.length; i++) digest[i] = strfhex32(digest[i]);
319 |       return digest.join("");
320 |     }
321 |   };
322 |   
323 |   Spec.describe("sha1", {
324 |     "SHA1#hexdigest": function() {
325 |       Spec.should.equal(new SHA1("").hexdigest(),       "da39a3ee5e6b4b0d3255bfef95601890afd80709");
326 |       Spec.should.equal(new SHA1("1").hexdigest(),      "356a192b7913b04c54574d18c28d46e6395428ab");
327 |       Spec.should.equal(new SHA1("Hello.").hexdigest(), "9b56d519ccd9e1e5b2a725e186184cdc68de0731");
328 |       Spec.should.equal(new SHA1("9b56d519ccd9e1e5b2a725e186184cdc68de0731").hexdigest(), "f042dc98a62cbad68dbe21f11bbc1e9d416d2bf6");
329 |       Spec.should.equal(new SHA1("MD5abZRVSXZVRcasdfasdddddddddddddddds+BNRJFSLKJFN+SEONBBJFJXLKCJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wurJFSE)RUNVXDLILKVJRN)#NVFJ)WVFWRW#)NVS$Q=$dddddddddddddWV;no9wuraddddddasdfasdfd").hexdigest(), "662dbf4ebc9cdb4224766e87634e5ba9e6de672b");
330 |     }
331 |   });
332 |   
333 |   return SHA1;
334 | })();
335 | 
336 | exports.SHA1 = SHA1; // add for node.js
337 | 


--------------------------------------------------------------------------------
/lib/mysql/types.js:
--------------------------------------------------------------------------------
  1 | var constants = require('./constants');
  2 | 
  3 | var Time = function(year, month, day, hour, minute, second, neg, second_part) {
  4 |     this.year = year || 0;
  5 |     this.month = month || 0;
  6 |     this.day = day || 0;
  7 |     this.hour = hour || 0;
  8 |     this.minute = minute || 0;
  9 |     this.second = second || 0;
 10 |     this.neg = !!neg;
 11 |     this.second_part = second_part;
 12 |     return this;
 13 | }
 14 | exports.Time = Time;
 15 | 
 16 | Time.prototype.toString = function() {
 17 |     var date = [this.year, this.month, this.day].join("-");
 18 |     var time = [this.hour, this.minute, this.second].join(":");
 19 |     if(date=='0-0-0') return time;
 20 |     return [date, time].join(' ');
 21 | }
 22 | 
 23 | Time.prototype.equals = function(obj) {
 24 |     return this.year == obj.year && this.month == obj.month && this.day == obj.day && this.hour == obj.hour && this.minute == obj.minute && this.second == obj.second;
 25 | }
 26 | 
 27 | var convertToSQLString = function(val) {
 28 |     switch(typeof(val)) {
 29 |     case 'undefined':
 30 | 	return 'NULL';
 31 |     case 'string':
 32 | 	return "'"+quote(val)+"'"
 33 |     case 'boolean':
 34 | 	return val?'true':'false';
 35 |     case 'number':
 36 | 	return String(val);
 37 |     }
 38 |     if(val.join) { // if array
 39 | 	return convertToSQLString(val.join(','));
 40 |     }
 41 |     return "'"+quote(String(val))+"'";
 42 | }
 43 | exports.convertToSQLString = convertToSQLString;
 44 | 
 45 | var quote = function(str) {
 46 |     return str.replace(/[\0\n\r\\\'\"\x1a]/g, function(s) {
 47 | 	switch(s) {
 48 |         case "\0":
 49 | 	    return "\\0";
 50 |         case "\n":
 51 | 	    return "\\n";
 52 |         case "\r":
 53 | 	    return "\\r";
 54 |         case "\x1a":
 55 | 	    return "\\Z";
 56 |         default:
 57 | 	    return "\\"+s;
 58 | 	}
 59 |     });
 60 | }
 61 | exports.quote = quote;
 62 | 
 63 | var parseTime = function(val) {
 64 |     var part = val.match(/^(0*(\d+) |)0*(\d+):0*(\d+):+0*(\d+)/);
 65 |     if(part) {
 66 | 	part = part.map(function(s) {
 67 | 	    return typeof(s)=='undefined' ? 0 : parseInt(s);
 68 | 	});
 69 | 	return new Time(0, 0, part[2], part[3], part[4], part[5]);
 70 |     }
 71 |     var part = val.match(/^(0*(\d+)-0*(\d+)-|)0*(\d+) *(0*(\d+):0*(\d+):+0*(\d+)|)/);
 72 |     if(part) {
 73 | 	part = part.map(function(s) {
 74 | 	    return typeof(s)=='undefined' ? 0 : parseInt(s);
 75 | 	});
 76 | 	return new Time(part[2], part[3], part[4], part[6], part[7], part[8]);
 77 |     }
 78 |     return undefined;
 79 | }
 80 | 
 81 | var Types = {};
 82 | Types[constants.field.TYPE_DECIMAL] = {
 83 |     id: constants.field.TYPE_DECIMAL,
 84 |     name: 'DECIMAL',
 85 |     convert: function(val, charset, field) {
 86 |         return typeof(val)=='undefined' ? null : parseFloat(val);
 87 |     }
 88 | };
 89 |     
 90 | Types[constants.field.TYPE_TINY] = {
 91 |     id: constants.field.TYPE_TINY,
 92 |     name: 'TINY',
 93 |     convert: function(val, charset, field) {
 94 |         return typeof(val)=='undefined' ? null : parseInt(val);
 95 |     }
 96 | };
 97 | 
 98 | Types[constants.field.TYPE_SHORT] = {
 99 |     id: constants.field.TYPE_SHORT,
100 |     name: 'SHORT',
101 |     convert: function(val, charset, field) {
102 |         return typeof(val)=='undefined' ? null : parseInt(val);
103 |     }
104 | };
105 | 
106 | Types[constants.field.TYPE_LONG] = {
107 |     id: constants.field.TYPE_LONG,
108 |     name: 'LONG',
109 |     convert: function(val, charset, field) {
110 |         return typeof(val)=='undefined' ? null : parseInt(val);
111 |     }
112 | };
113 | 
114 | Types[constants.field.TYPE_FLOAT] = {
115 |     id: constants.field.TYPE_FLOAT,
116 |     name: 'FLOAT',
117 |     convert: function(val, charset, field) {
118 |         return typeof(val)=='undefined' ? null : parseFloat(val);
119 |     }
120 | };
121 | 
122 | Types[constants.field.TYPE_DOUBLE] = {
123 |     id: constants.field.TYPE_DOUBLE,
124 |     name: 'DOUBLE',
125 |     convert: function(val, charset, field) {
126 |         return typeof(val)=='undefined' ? null : parseFloat(val);
127 |     }
128 | };
129 | 
130 | Types[constants.field.TYPE_NULL] = {
131 |     id: constants.field.TYPE_NULL,
132 |     name: 'NULL',
133 |     convert: function(val, charset, field) {
134 |         return null;
135 |     }
136 | };
137 | 
138 | Types[constants.field.TYPE_TIMESTAMP] = {
139 |     id: constants.field.TYPE_TIMESTAMP,
140 |     name: 'TIMESTAMP',
141 |     convert: function(val, charset, field) {
142 |         return typeof(val)=='undefined' ? null : parseTime(val);
143 |     }
144 | };
145 | 
146 | Types[constants.field.TYPE_LONGLONG] = {
147 |     id: constants.field.TYPE_LONGLONG,
148 |     name: 'LONGLONG',
149 |     convert: function(val, charset, field) {
150 |         return typeof(val)=='undefined' ? null : parseInt(val);
151 |     }
152 | };
153 | 
154 | Types[constants.field.TYPE_INT24] = {
155 |     id: constants.field.TYPE_INT24,
156 |     name: 'INT24',
157 |     convert: function(val, charset, field) {
158 |         return typeof(val)=='undefined' ? null : parseInt(val);
159 |     }
160 | };
161 | 
162 | Types[constants.field.TYPE_DATE] = {
163 |     id: constants.field.TYPE_DATE,
164 |     name: 'DATE',
165 |     convert: function(val, charset, field) {
166 |         return typeof(val)=='undefined' ? null : parseTime(val);
167 |     }
168 | };
169 | 
170 | Types[constants.field.TYPE_TIME] = {
171 |     id: constants.field.TYPE_TIME,
172 |     name: 'TIME',
173 |     convert: function(val, charset, field) {
174 |         return typeof(val)=='undefined' ? null : parseTime(val);
175 |     }
176 | };
177 | 
178 | Types[constants.field.TYPE_DATETIME] = {
179 |     id: constants.field.TYPE_DATETIME,
180 |     name: 'DATETIME',
181 |     convert: function(val, charset, field) {
182 |         return typeof(val)=='undefined' ? null : parseTime(val);
183 |     }
184 | };
185 | 
186 | Types[constants.field.TYPE_YEAR] = {
187 |     id: constants.field.TYPE_YEAR,
188 |     name: 'YEAR',
189 |     convert: function(val, charset, field) {
190 |         return typeof(val)=='undefined' ? null : parseInt(val);
191 |     }
192 | };
193 | 
194 | Types[constants.field.TYPE_NEWDATE] = {
195 |     id: constants.field.TYPE_NEWDATE,
196 |     name: 'NEWDATE',
197 |     convert: function(val, charset, field) {
198 |         return typeof(val)=='undefined' ? null : parseTime(val);
199 |     }
200 | };
201 | 
202 | Types[constants.field.TYPE_VARCHAR] = {
203 |     id: constants.field.TYPE_VARCHAR,
204 |     name: 'VARCHAR',
205 |     convert: function(val, charset, field) {
206 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
207 |     }
208 | };
209 | 
210 | Types[constants.field.TYPE_BIT] = {
211 |     id: constants.field.TYPE_BIT,
212 |     name: 'BIT',
213 |     convert: function(val, charset, field) {
214 |         return typeof(val)=='undefined' ? null : val;
215 |     }
216 | };
217 | 
218 | Types[constants.field.TYPE_NEWDECIMAL] = {
219 |     id: constants.field.TYPE_NEWDECIMAL,
220 |     name: 'NEWDECIMAL',
221 |     convert: function(val, charset, field) {
222 |         return typeof(val)=='undefined' ? null : parseFloat(val);
223 |     }
224 | };
225 | 
226 | Types[constants.field.TYPE_ENUM] = {
227 |     id: constants.field.TYPE_ENUM,
228 |     name: 'ENUM',
229 |     convert: function(val, charset, field) {
230 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
231 |     }
232 | };
233 | 
234 | Types[constants.field.TYPE_SET] = {
235 |     id: constants.field.TYPE_SET,
236 |     name: 'SET',
237 |     convert: function(val, charset, field) {
238 |         if(typeof(val)=='undefined') return undefined;
239 |         return val=='' ? [] : charset.convertFromBytes(val.split(','));
240 |     }
241 | };
242 | 
243 | Types[constants.field.TYPE_TINY_BLOB] = {
244 |     id: constants.field.TYPE_TINY_BLOB,
245 |     name: 'TINY_BLOB',
246 |     convert: function(val, charset, field) {
247 | 	if(field.flags & constants.field.BINARY_FLAG) return val;
248 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
249 |     }
250 | };
251 | 
252 | Types[constants.field.TYPE_MEDIUM_BLOB] = {
253 |     id: constants.field.TYPE_MEDIUM_BLOB,
254 |     name: 'MEDIUM_BLOB',
255 |     convert: function(val, charset, field) {
256 | 	if(field.flags & constants.field.BINARY_FLAG) return val;
257 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
258 |     }
259 | };
260 | 
261 | Types[constants.field.TYPE_LONG_BLOB] = {
262 |     id: constants.field.TYPE_LONG_BLOB,
263 |     name: 'LONG_BLOB',
264 |     convert: function(val, charset, field) {
265 | 	if(field.flags & constants.field.BINARY_FLAG) return val;
266 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
267 |     }
268 | };
269 | 
270 | Types[constants.field.TYPE_BLOB] = {
271 |     id: constants.field.TYPE_BLOB,
272 |     name: 'BLOB',
273 |     convert: function(val, charset, field) {
274 | 	if(field.flags & constants.field.BINARY_FLAG) return val;
275 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
276 |     }
277 | };
278 | 
279 | Types[constants.field.TYPE_VAR_STRING] = {
280 |     id: constants.field.TYPE_VAR_STRING,
281 |     name: 'VAR_STRING',
282 |     convert: function(val, charset, field) {
283 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
284 |     }
285 | };
286 | 
287 | Types[constants.field.TYPE_STRING] = {
288 |     id: constants.field.TYPE_STRING,
289 |     name: 'STRING',
290 |     convert: function(val, charset, field) {
291 |         return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
292 |     }
293 | };
294 | 
295 | Types[constants.field.TYPE_GEOMETRY] = {
296 |     id: constants.field.TYPE_GEOMETRY,
297 |     name: 'GEOMETRY',
298 |     convert: function(val, charset, field) {
299 |         return typeof(val)=='undefined' ? null : val;
300 |     }
301 | };
302 | 
303 | exports.Types = Types;


--------------------------------------------------------------------------------
/lib/mysql/utils.js:
--------------------------------------------------------------------------------
1 | var scope = function(target, func) {
2 |     return function(){ return func.apply(target, arguments); }
3 | }
4 | exports.scope = scope;
5 | 


--------------------------------------------------------------------------------
/test/config.js:
--------------------------------------------------------------------------------
 1 | var merge = function(obj1, obj2) {
 2 |     var ret = {};
 3 |     for (var property in obj1)
 4 | 	ret[property] = obj1[property];
 5 |     for (var property in obj2)
 6 | 	ret[property] = obj2[property];
 7 |     return ret;
 8 | }
 9 | 
10 | var mysql = {
11 |     hostname: '127.0.0.1',
12 |     port: 3306,
13 |     
14 |     username: 'nodejs_mysql',
15 |     password: 'nodejs_mysql',
16 |     database: 'nodejs_mysql'
17 | };
18 | 
19 | exports.mysql_ignore_account = merge(mysql, {
20 |     username: 'nodejs_foobar'
21 | });
22 | 
23 | exports.mysql_ignore_password = merge(mysql, {
24 |     password: 'nodejs_foobar'
25 | });
26 | 
27 | exports.mysql_ignore_port = merge(mysql, {
28 |     port: 1
29 | });
30 | 
31 | exports.mysql = mysql;
32 | 


--------------------------------------------------------------------------------
/test/fixtures/data1.csv:
--------------------------------------------------------------------------------
1 | 1	abc
2 | 2	def


--------------------------------------------------------------------------------
/test/helper.js:
--------------------------------------------------------------------------------
 1 | var sys = require("sys");
 2 | var assert = require("assert");
 3 | 
 4 | var scope = function(target, func) {
 5 |     return function(){ return func.apply(target, arguments); }
 6 | }
 7 | exports.scope = scope;
 8 | 
 9 | var pending_callbacks = 0;
10 | exports.pending_callbacks = pending_callbacks;
11 | 
12 | var expect_callback = function() {
13 |   pending_callbacks++;
14 | }
15 | exports.expect_callback = expect_callback;
16 | 
17 | var was_called_back = function() {
18 |   pending_callbacks--;
19 | }
20 | exports.was_called_back = was_called_back;
21 | 
22 | var createMockConnection = function(mysql, stream) {
23 |     var conn = new mysql.Connection('localhost', 
24 | 				    'nodejs_mysql',
25 | 				    'nodejs_mysql',
26 | 				    'nodejs_mysql',
27 | 				    33306);
28 |     exports.exceptClass(mysql.Connection, conn);
29 |     conn.addListener("connect", function() {
30 | 	conn.protocol.conn.socket.write(stream);
31 |     });
32 |     return conn;
33 | }
34 | exports.createMockConnection = createMockConnection;
35 | 
36 | var run = function(testfuncs){
37 |     pending_callbacks = 0;
38 |     var testfunc = testfuncs.shift();
39 |     if(!testfunc) return true;
40 |     var promise = testfunc[1]();
41 |     if(promise) {
42 | 	promise
43 | 	    .addCallback(function() {
44 | 		assert.equal(0, pending_callbacks);
45 | 		sys.puts("Success: "+testfunc[0]);
46 | 		run(testfuncs);
47 | 	    })
48 | 	    .addErrback(function() {
49 | 		sys.puts("Failed: "+testfunc[0]);
50 | 		run(testfuncs);
51 | 	    });
52 |     }
53 |     else {
54 | 	sys.puts("Tested: "+testfunc[0])
55 | 	run(testfuncs);
56 |     }
57 | }
58 | exports.run = run;
59 | 
60 | var exceptClass = function(klass,obj) {
61 |     assert.equal(klass.contructor, obj.constractor);
62 | }
63 | exports.exceptClass = exceptClass;
64 | 
65 | /*
66 | node-mysql
67 | A node.js interface for MySQL
68 | 
69 | Author: masuidrive <masui@masuidrive.jp>
70 | License: MIT License
71 | Copyright (c) Yuichiro MASUI
72 | */
73 | 


--------------------------------------------------------------------------------
/test/mysql_stub.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | var sys = require("sys");
  3 | var tcp = require("net");
  4 | var test = require("mjsunit");
  5 | 
  6 | var streams = {
  7 |     "authentication timeout": [
  8 | 	["server", "38 00 00 00"],
  9 | 	["server", "0a 35 2e 31 2e 34 33 2d 6c 6f 67 00 7d 13 00 00 52 7a 33 2a 76 38 51 6d 00 ff f7 08 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 53 39 60 58 79 77 69 2b 36 6f 4e 78 00"],
 10 | 	["client", "4f 00 00 01"],
 11 | 	["client", "0d a2 00 00 00 00 00 40 21 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00 14 3a 92 54 0d f9 cc b8 79 34 04 6c f4 2d a0 69 58 4e cc 01 40 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00"],
 12 | 	["sleep", 10*1000] // Timeout
 13 |     ],
 14 |     
 15 |     "shutdown on authentication": [
 16 | 	["server", "38 00 00 00"],
 17 | 	["server", "0a 35 2e 31 2e 34 33 2d 6c 6f 67 00 7d 13 00 00 52 7a 33 2a 76 38 51 6d 00 ff f7 08 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 53 39 60 58 79 77 69 2b 36 6f 4e 78 00"],
 18 | 	["client", "4f 00 00 01"],
 19 | 	["client", "0d a2 00 00 00 00 00 40 21 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00 14 3a 92 54 0d f9 cc b8 79 34 04 6c f4 2d a0 69 58 4e cc 01 40 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00"],
 20 | 	["close"]
 21 |     ],
 22 |     
 23 |     "protocol version 11": [
 24 | 	["server", "38 00 00 00"],
 25 | 	["server", "0b 35 2e 31 2e 34 33 2d 6c 6f 67 00 7d 13 00 00 52 7a 33 2a 76 38 51 6d 00 ff f7 08 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 53 39 60 58 79 77 69 2b 36 6f 4e 78 00"],
 26 | 	['close']
 27 |     ],
 28 |     
 29 |     "query timeout": [
 30 | 	["server", "38 00 00 00"],
 31 | 	["server", "0a 35 2e 31 2e 34 33 2d 6c 6f 67 00 7d 13 00 00 52 7a 33 2a 76 38 51 6d 00 ff f7 08 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 53 39 60 58 79 77 69 2b 36 6f 4e 78 00"],
 32 | 	["client", "4f 00 00 01"],
 33 | 	["client", "0d a2 00 00 00 00 00 40 21 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00 14 3a 92 54 0d f9 cc b8 79 34 04 6c f4 2d a0 69 58 4e cc 01 40 6e 6f 64 65 6a 73 5f 6d 79 73 71 6c 00"],
 34 | 	["server", "07 00 00 02"],
 35 | 	["server", "00 00 00 02 00 00 00"],
 36 | 	["client", "11 00 00 00"],
 37 | 	["client", "03 53 45 54 20 4e 41 4d 45 53 20 27 75 74 66 38 27"], // SET NAMES 'utf8'
 38 | 	["server", "07 00 00 01"],
 39 | 	["server", "00 00 00 02 00 00 00"],
 40 | 	["client", "0c 00 00 00"],
 41 | 	["client", "03 53 45 4c 45 43 54 20 31 2e 32 33"], // SELECT 1.23
 42 | 	["sleep", 10*1000] // Timeout
 43 |     ]
 44 | };
 45 | 
 46 | var server = tcp.createServer(function (socket) {
 47 |     var toString = function(x){
 48 |         return x.toString();
 49 |     }
 50 |     var hex2bin = function(str) {
 51 | 	str = toString(str);
 52 |        	return str.split(' ').map(function(s){return String.fromCharCode(parseInt(s,16));}).join('');
 53 |     }
 54 |     var bin2hex = function (str){
 55 | 	str = toString(str);
 56 |         return str.split('').map(function(s){return ((s.charCodeAt(0)<16?"0":'')+s.charCodeAt(0).toString(16)).substring();}).join(' ');
 57 |     }
 58 |     
 59 |     var write_process = function() {
 60 | 	if(current_stream && current_stream.length>0) {
 61 | 	    if(current_stream[0][0]=="server") {
 62 | 		var line = current_stream.shift();
 63 | 		sys.puts("Server> "+bin2hex(hex2bin(line[1])));
 64 | 		socket.write(hex2bin(line[1]), 'binary');
 65 | 		write_process();
 66 | 	    }
 67 | 	    else if(current_stream[0][0]=="sleep") {
 68 | 		var line = current_stream.shift();
 69 | 		sys.puts("Sleep> "+line[1]);
 70 | 		setTimeout(write_process, line[1]);
 71 | 	    }
 72 | 	    else if(current_stream[0][0]=="close") {
 73 | 		var line = current_stream.shift();
 74 | 		sys.puts("Close");
 75 | 		socket.end();
 76 | 	    }
 77 | 	}
 78 |     }
 79 |     
 80 |     var current_stream = undefined;
 81 |     socket.setEncoding("binary");
 82 |     socket.setNoDelay(true);
 83 |     socket.setTimeout(0);
 84 | 
 85 |     socket.addListener("connect", function () {
 86 | 	current_stream = undefined;
 87 | 	sys.puts("Connect");
 88 |     });
 89 |     socket.addListener("data", function (data) {
 90 | 	if(current_stream) {
 91 | 	    sys.puts("Client< "+bin2hex(data)+"\n");
 92 | 	    var line = current_stream.shift();
 93 |       
 94 | 	    if(line[0]=="server") {
 95 |       		return sys.puts("Sequence error");
 96 | 	    }
 97 | 	    
 98 | 	    var bin = hex2bin(line[1]);
 99 | 	    while(bin.length < data.length) {
100 | 		var next_line = current_stream.shift();
101 | 		if(typeof(next_line)=='undefined' || next_line[0]=="server") {
102 |       		    return sys.puts("Sequence error");
103 | 		}
104 | 		bin += hex2bin(next_line[1]);
105 | 	    }
106 | 	    
107 | 	    if(bin!=data) {
108 | 		sys.puts("Data mismatch");
109 | 		sys.puts("Expected ( '" + bin2hex(bin) + "' )  vs ");
110 | 		sys.puts("DATA     ( '" + bin2hex(data) + "' ) \n\n");
111 | 		return false;
112 | 	    }
113 | 	}
114 | 	else {
115 | 	    sys.puts(data);
116 | 	    current_stream = Array.apply(null, streams[data]);
117 | 	}
118 | 	write_process(socket);
119 |     });
120 |     socket.addListener("end", function () {
121 | 	if(current_stream.length>0) sys.puts("Sequence left: "+current_stream.join(", "));
122 | 	socket.end();
123 | 	current_stream = undefined;
124 | 	sys.puts("Closed\n");
125 |     });
126 | });
127 | sys.puts("Start Mysql Stub for test on localhost:33306")
128 | server.listen(33306, "localhost");
129 | 


--------------------------------------------------------------------------------
/test/test.real_mysql.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | GLOBAL.DEBUG = true;
  3 | var events = require("events");
  4 | var sys = require("sys");
  5 | var assert = require("assert");
  6 | 
  7 | var helper = require('./helper');
  8 | var config = require('./config');
  9 | var mysql = require('../lib/mysql');
 10 | var Promise = require('../lib/mysql/node-promise').Promise;
 11 | 
 12 | var all_tests = [];
 13 | var test_createConnection = function() {
 14 |     var promise = new Promise();
 15 |     var conn = new mysql.Connection(config.mysql.hostname,
 16 | 				    config.mysql.username,
 17 | 				    config.mysql.password,
 18 | 				    config.mysql.database);
 19 |     helper.exceptClass(mysql.Connection, conn);
 20 |     helper.expect_callback();
 21 |     conn.connect(function() {
 22 | 	helper.was_called_back();
 23 | 	conn.close();
 24 | 	promise.emitSuccess();
 25 |     });
 26 |     return promise
 27 | };
 28 | all_tests.push(["createConnection", test_createConnection]);
 29 | 
 30 | var test_result1 = function() {
 31 |     var promise = new Promise();
 32 |     var conn = new mysql.Connection(config.mysql.hostname, 
 33 | 					  config.mysql.username,
 34 | 					  config.mysql.password,
 35 | 					  config.mysql.database);
 36 |     helper.exceptClass(mysql.Connection, conn);
 37 |     conn.connect();
 38 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER, str VARCHAR(254), PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
 39 |     conn.query("INSERT INTO t VALUES (1,'abc'),(2,'0'),(3,''),(256,null)");
 40 |     
 41 |     // execute SELECT query
 42 |     helper.expect_callback();
 43 |     conn.query('SELECT * FROM t ORDER BY id', function(result) { // Success
 44 | 	helper.was_called_back();
 45 | 	
 46 | 	// field information
 47 | 	assert.equal(2, result.fields.length);
 48 | 	assert.equal('LONG', result.fields[0].type.name);
 49 | 	assert.equal('nodejs_mysql', result.fields[0].db);
 50 | 	assert.equal('id', result.fields[0].name);
 51 | 	assert.equal('id', result.fields[0].org_name);
 52 | 	assert.equal('t', result.fields[0].table);
 53 | 	assert.equal('t', result.fields[0].org_table);
 54 | 	assert.equal(11, result.fields[0].length);
 55 | 	assert.equal(0, result.fields[0].decimals);
 56 | 	assert.equal(undefined, result.fields[0].defaultValue);
 57 | 	assert.equal(mysql.constants.field.PRI_KEY_FLAG
 58 | 			  | mysql.constants.field.PART_KEY_FLAG
 59 | 			  | mysql.constants.field.NOT_NULL_FLAG,
 60 | 			  result.fields[0].flags);
 61 | 	assert.equal(true, result.fields[0].is_num());
 62 | 	assert.equal(true, result.fields[0].is_not_null());
 63 | 	assert.equal(true, result.fields[0].is_pri_key());
 64 | 	
 65 | 	assert.equal('VAR_STRING', result.fields[1].type.name);
 66 | 	assert.equal('nodejs_mysql', result.fields[1].db);
 67 | 	assert.equal('str', result.fields[1].name);
 68 | 	assert.equal('str', result.fields[1].org_name);
 69 | 	assert.equal('t', result.fields[1].table);
 70 | 	assert.equal('t', result.fields[1].org_table);
 71 | 	assert.equal(0, result.fields[1].decimals);
 72 | 	assert.equal(undefined, result.fields[0].defaultValue);
 73 | 	assert.equal(0, result.fields[1].flags);
 74 | 	assert.equal(false, result.fields[1].is_num());
 75 | 	assert.equal(false, result.fields[1].is_not_null());
 76 | 	assert.equal(false, result.fields[1].is_pri_key());
 77 | 	
 78 | 	// result data
 79 | 	assert.equal(4, result.records.length);
 80 | 	assert.equal(1, result.records[0][0]);
 81 | 	assert.equal('abc', result.records[0][1]); // string
 82 | 	assert.equal(2, result.records[1][0]);
 83 | 	assert.equal('0', result.records[1][1]); // string
 84 | 	assert.equal(3, result.records[2][0]);
 85 | 	assert.equal('', result.records[2][1]); // blank string
 86 | 	assert.equal(256, result.records[3][0]);
 87 | 	assert.equal(undefined, result.records[3][1]); // null string
 88 | 	
 89 | 	// result hash fieldname
 90 | 	var res = result.toHash(result.records[0]);
 91 | 	assert.equal(res['id'], 1);
 92 | 	assert.equal(res['str'], 'abc');
 93 | 	var res = result.toHash(result.records[1]);
 94 | 	assert.equal(res['id'], 2);
 95 | 	assert.equal(res['str'], '0');
 96 | 	var res = result.toHash(result.records[2]);
 97 | 	assert.equal(res['id'], 3);
 98 | 	assert.equal(res['str'], '');
 99 | 	var res = result.toHash(result.records[3]);
100 | 	assert.equal(res['id'], 256);
101 | 	assert.equal(res['str'], undefined);
102 | 	
103 | 	// result hash with table name
104 | 	result.fieldname_with_table = true
105 | 	var res = result.toHash(result.records[0]);
106 | 	assert.equal(res['t.id'], 1);
107 | 	assert.equal(res['t.str'], 'abc');
108 | 	var res = result.toHash(result.records[1]);
109 | 	assert.equal(res['t.id'], 2);
110 | 	assert.equal(res['t.str'], '0');
111 | 	var res = result.toHash(result.records[2]);
112 | 	assert.equal(res['t.id'], 3);
113 | 	assert.equal(res['t.str'], '');
114 | 	var res = result.toHash(result.records[3]);
115 | 	assert.equal(res['t.id'], 256);
116 | 	assert.equal(res['t.str'], undefined);
117 | 
118 | 	// result hash fieldname
119 | 	result.fieldname_with_table = false
120 | 	var res = result.toHash(result.records[0]);
121 | 	assert.equal(res['id'], 1);
122 | 	assert.equal(res['str'], 'abc');
123 | 	var res = result.toHash(result.records[1]);
124 | 	assert.equal(res['id'], 2);
125 | 	assert.equal(res['str'], '0');
126 | 	var res = result.toHash(result.records[2]);
127 | 	assert.equal(res['id'], 3);
128 | 	assert.equal(res['str'], '');
129 | 	var res = result.toHash(result.records[3]);
130 | 	assert.equal(res['id'], 256);
131 | 	assert.equal(res['str'], undefined);
132 |     });
133 | 
134 |     // table & column alias
135 |     helper.expect_callback();
136 |     conn.query('SELECT id as pkey FROM t as ttt ORDER BY pkey', function(result) {
137 | 	helper.was_called_back();
138 | 	
139 | 	// field information
140 | 	assert.equal(1, result.fields.length);
141 | 	assert.equal('LONG', result.fields[0].type.name);
142 | 	assert.equal('nodejs_mysql', result.fields[0].db);
143 | 	assert.equal('pkey', result.fields[0].name);
144 | 	assert.equal('id', result.fields[0].org_name);
145 | 	assert.equal('ttt', result.fields[0].table);
146 | 	assert.equal('t', result.fields[0].org_table);
147 | 	assert.equal(undefined, result.fields[0].defaultValue);
148 | 	
149 | 	// result data
150 | 	assert.equal(4, result.records.length);
151 | 	assert.equal(1, result.records[0][0]);
152 | 	assert.equal(2, result.records[1][0]);
153 | 	assert.equal(3, result.records[2][0]);
154 | 	assert.equal(256, result.records[3][0]);
155 | 	
156 | 	// result hash
157 | 	result.fieldname_with_table = true
158 | 	var res = result.toHash(result.records[0]);
159 | 	assert.equal(res['ttt.pkey'], 1);
160 | 	var res = result.toHash(result.records[1]);
161 | 	assert.equal(res['ttt.pkey'], 2);
162 | 	var res = result.toHash(result.records[2]);
163 | 	assert.equal(res['ttt.pkey'], 3);
164 | 	var res = result.toHash(result.records[3]);
165 | 	assert.equal(res['ttt.pkey'], 256);
166 | 
167 | 	// result hash fieldname without table
168 | 	result.fieldname_with_table = false
169 | 	var res = result.toHash(result.records[0]);
170 | 	assert.equal(res['pkey'], 1);
171 | 	var res = result.toHash(result.records[1]);
172 | 	assert.equal(res['pkey'], 2);
173 | 	var res = result.toHash(result.records[2]);
174 | 	assert.equal(res['pkey'], 3);
175 | 	var res = result.toHash(result.records[3]);
176 | 	assert.equal(res['pkey'], 256);
177 | 	
178 | 	conn.close();
179 | 	promise.emitSuccess();
180 |     },
181 |     function(error) { 
182 | 	conn.close();
183 | 	promise.emitFailure();
184 |     });
185 | 
186 |     return promise;
187 | };
188 | all_tests.push(["test_result1", test_result1]);
189 | 
190 | var test_insert256rows = function() {
191 |     var promise = new Promise();
192 |     var conn = new mysql.Connection(config.mysql.hostname, 
193 | 					  config.mysql.username,
194 | 					  config.mysql.password,
195 | 					  config.mysql.database);
196 |     helper.exceptClass(mysql.Connection, conn);
197 |     conn.connect();
198 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER)");
199 |     var q = [];
200 |     for(var i=0; i<256; ++i) {
201 | 	q.push("("+i+")");
202 |     }
203 |     conn.query("INSERT INTO t(id) VALUES "+q.join(","), function(result) {
204 | 	assert.equal(256, result.affected_rows);
205 |     });
206 |     
207 |     // execute SELECT query
208 |     helper.expect_callback();
209 |     conn.query('SELECT * FROM t ORDER BY id', function(result) { // Success
210 | 	helper.was_called_back();
211 | 	
212 | 	assert.equal(1, result.fields.length);
213 | 	assert.equal(256, result.records.length);
214 | 	
215 | 	conn.close();
216 | 	promise.emitSuccess();
217 |     },
218 |     function(error) { 
219 |          assert.ok(false);
220 |     });
221 | 
222 |     return promise;
223 | };
224 | all_tests.push(["test_insert256rows", test_insert256rows]);
225 | 
226 | 
227 | var test_query_without_table = function() {
228 |     var promise = new Promise();
229 |     var conn = new mysql.Connection(config.mysql.hostname, 
230 | 					  config.mysql.username,
231 | 					  config.mysql.password,
232 | 					  config.mysql.database);
233 |     helper.exceptClass(mysql.Connection, conn);
234 |     conn.connect();
235 | 
236 |     helper.expect_callback();
237 |     conn.query('SELECT 1.23',
238 | 	       function(result) {
239 | 		   helper.was_called_back();
240 | 		   
241 | 		   // field information
242 | 		   assert.equal(1, result.fields.length);
243 | 		   assert.equal('NEWDECIMAL', result.fields[0].type.name);
244 | 		   assert.equal('', result.fields[0].db);
245 | 		   assert.equal('1.23', result.fields[0].name);
246 | 		   assert.equal('', result.fields[0].org_name);
247 | 		   assert.equal('', result.fields[0].table);
248 | 		   assert.equal('', result.fields[0].org_table);
249 | 		   assert.equal(false, conn.has_more_results());
250 | 		   
251 | 		   // result data
252 | 		   assert.equal(1, result.records.length);
253 | 		   assert.equal(1.23, result.records[0][0]);
254 | 		   
255 | 		   // result hash
256 | 		   var res = result.toHash(result.records[0]);
257 | 		   assert.equal(res['1.23'], 1.23);
258 | 		   
259 | 		   // result hash fieldname without table
260 | 		   result.fieldname_with_table = false
261 | 		   var res = result.toHash(result.records[0]);
262 | 		   assert.equal(res['1.23'], 1.23);
263 | 		   conn.close();
264 | 		   promise.emitSuccess();
265 | 	       }, 
266 | 	       function(error) { 
267 | 		   assert.ok(true, false);
268 | 	       });
269 |     return promise;
270 | }
271 | all_tests.push(["test_query_without_table", test_query_without_table]);
272 | 
273 | 
274 | var test_placeholder = function() {
275 |     var promise = new Promise();
276 |     var conn = new mysql.Connection(config.mysql.hostname, 
277 | 					  config.mysql.username,
278 | 					  config.mysql.password,
279 | 					  config.mysql.database);
280 |     helper.exceptClass(mysql.Connection, conn);
281 |     conn.connect();
282 |     
283 |     var sql = conn.extract_placeholder(['SELECT ?,?,?,?,?,?,?,?', 123, 1.23, 'abc', true, false, new mysql.Time(1976,2,8), new mysql.Time(0,0,0,12,34,56), new mysql.Time(1976,2,8,12,34,56)]);
284 |     assert.equal("SELECT 123,1.23,'abc',true,false,'1976-2-8 0:0:0','12:34:56','1976-2-8 12:34:56'", sql);
285 |     
286 |     helper.expect_callback();
287 |     conn.query(['SELECT ?,?', 123],
288 | 	       function(result) {
289 | 		   assert.ok(true, false);
290 | 	       }, 
291 | 	       function(error) {
292 | 		   helper.was_called_back();
293 | 		   assert.equal('parameter count mismatch', error.message);
294 | 	       });
295 | 
296 |     helper.expect_callback();
297 |     conn.query(['SELECT ?', 123, 456],
298 | 	       function(result) {
299 | 		   assert.ok(true, false);
300 | 	       }, 
301 | 	       function(error) {
302 | 		   helper.was_called_back();
303 | 		   assert.equal('parameter count mismatch', error.message);
304 | 	       });
305 | 
306 |     helper.expect_callback();
307 |     conn.query(['SELECT ?,?,?,?,?', 123, 1.23, 'abc', true, false],
308 | 	       function(result) {
309 | 		   helper.was_called_back();
310 | 		   
311 | 		   // field information
312 | 		   assert.equal(5, result.fields.length);
313 | 		   
314 | 		   // result data
315 | 		   assert.equal(1, result.records.length);
316 | 		   assert.equal(123, result.records[0][0]);
317 | 		   assert.equal(1.23, result.records[0][1]);
318 | 		   assert.equal('abc', result.records[0][2]);
319 | 		   assert.equal(1, result.records[0][3]);
320 | 		   assert.equal(0, result.records[0][4]);
321 | 		   conn.close();
322 | 		   promise.emitSuccess();
323 | 	       }, 
324 | 	       function(error) {
325 | 		   sys.puts(sys.inspect(error));
326 | 		   assert.ok(true, false);
327 | 	       });
328 |     return promise
329 | }
330 | all_tests.push(["test_placeholder", test_placeholder]);
331 | 
332 | 
333 | var test_multi_statements = function() {
334 |     var promise = new Promise();
335 |     var conn = new mysql.Connection(config.mysql.hostname, 
336 | 					  config.mysql.username,
337 | 					  config.mysql.password,
338 | 					  config.mysql.database);
339 |     helper.exceptClass(mysql.Connection, conn);
340 |     conn.connect();
341 | 
342 |     // multi statement without MULTI_STATEMENTS_ON
343 |     helper.expect_callback();
344 |     conn.query('SELECT 1,2; SELECT 3,4,5',
345 | 	       function(result) { // success
346 | 		   assert.ok(true, false);
347 | 	       },
348 | 	       function(error) { // fail
349 | 		   helper.was_called_back();
350 | 	       });
351 | 
352 |     // multi statement
353 |     conn.set_server_option(mysql.constants.option.MULTI_STATEMENTS_ON);
354 |     helper.expect_callback();
355 |     conn.query('SELECT 1,2; SELECT 3,4,5',
356 |                function(result) {
357 | 		   helper.was_called_back();
358 | 		   
359 | 		   // result 1st query data
360 | 		   assert.equal(1, result.records.length);
361 | 		   assert.equal(1, result.records[0][0]);
362 | 		   assert.equal(2, result.records[0][1]);
363 | 		   
364 | 		   assert.equal(true, conn.has_more_results());
365 | 		   helper.expect_callback();
366 | 		   conn.next_result(
367 | 		       function(result) {
368 | 			   helper.was_called_back();
369 | 			   // result 2nd query data
370 | 			   assert.equal(1, result.records.length);
371 | 			   assert.equal(3, result.records[0][0]);
372 | 			   assert.equal(4, result.records[0][1]);
373 | 			   assert.equal(5, result.records[0][2]);
374 | 			   
375 | 			   // no more data
376 | 			   assert.equal(false, conn.has_more_results());
377 | 			   conn.close();
378 | 			   promise.emitSuccess();
379 | 		       },
380 | 		       function(error){
381 | 			   assert.ok(true, false);
382 | 		       });
383 | 	       },
384 | 	       function(error) {
385 | 		   assert.ok(true, false);
386 | 	       });
387 |     return promise
388 | }
389 | all_tests.push(["test_multi_statements", test_multi_statements]);
390 | 
391 | 
392 | var test_quote = function(complete) {
393 |     assert.equal("abc\\'def\\\"ghi\\0jkl%mno\u8868", mysql.quote("abc'def\"ghi\0jkl%mno\u8868"));
394 | };
395 | all_tests.push(["test_quote", test_quote]);
396 | 
397 | 
398 | var test_prepared_statements = function() {
399 |     var promise = new Promise();
400 |     var conn = new mysql.Connection(config.mysql.hostname, 
401 | 	                            config.mysql.username,
402 | 				    config.mysql.password,
403 | 			            config.mysql.database);
404 |     helper.exceptClass(mysql.Connection, conn);
405 |     conn.connect();
406 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER, str VARCHAR(10), PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
407 |     
408 |     helper.expect_callback();
409 |     conn.prepare('INSERT INTO t VALUE (?,?)', function(stmt) {
410 | 	helper.was_called_back();
411 | 	stmt.execute([1, 'abc'], helper.scope(this, function(result) {
412 | 	    // verify inserted data
413 | 	    helper.expect_callback();
414 | 	    conn.query('SELECT * FROM t ORDER BY id', function(result) {
415 | 		helper.was_called_back();
416 | 		
417 | 		// result data
418 | 		assert.equal(1, result.records.length);
419 | 		assert.equal(1, result.records[0][0]);
420 | 		assert.equal('abc', result.records[0][1]);
421 | 		
422 | 		helper.expect_callback();
423 | 		stmt.execute([2,'def'], helper.scope(this, function(result) {
424 | 		    helper.was_called_back();
425 | 		    // verify inserted data
426 | 		    helper.expect_callback();
427 | 		    conn.query('SELECT * FROM t ORDER BY id', function(result) {
428 | 			helper.was_called_back();
429 | 			
430 | 			// result data
431 | 			assert.equal(2, result.records.length);
432 | 			assert.equal(1, result.records[0][0]);
433 | 			assert.equal('abc', result.records[0][1]);
434 | 			assert.equal(2, result.records[1][0]);
435 | 			assert.equal('def', result.records[1][1]);
436 | 			
437 | 			helper.expect_callback();
438 | 			stmt.execute([3,'def'], helper.scope(this, function(result) {
439 | 			    helper.was_called_back();
440 | 			    
441 | 			    helper.expect_callback();
442 | 			    conn.prepare('SELECT * FROM t WHERE str=? ORDER BY id', function(stmt2) {
443 | 				helper.was_called_back();
444 | 				helper.expect_callback();
445 | 				stmt2.execute(['def'],  helper.scope(this, function(result) {
446 | 				    helper.was_called_back();
447 | 				    // result data
448 | 				    assert.equal(2, result.records.length);
449 | 				    assert.equal(2, result.records[0][0]);
450 | 				    assert.equal('def', result.records[0][1]);
451 | 				    assert.equal(3, result.records[1][0]);
452 | 				    assert.equal('def', result.records[1][1]);
453 | 				    
454 | 				    conn.close();
455 | 				    promise.emitSuccess();
456 | 				}),
457 | 			        function(error){ assert.ok(true, false); });
458 | 			    },
459 | 			    function(error){ assert.ok(true, false); });
460 | 			}),
461 |                         function(error){ assert.ok(true, false); });
462 | 		    },
463 |                     function(error){ assert.ok(true, false); });
464 | 		}),
465 |                 function(error){ assert.ok(true, false); });
466 | 	    },
467 |             function(error){ assert.ok(true, false); });
468 | 	}),
469 |         function(error){ assert.ok(true, false); });
470 |     },
471 |     function(error){ assert.ok(true, false); });
472 |     return promise
473 | }
474 | all_tests.push(["test_prepared_statements", test_prepared_statements]);
475 | 
476 | 
477 | var test_transaction1 = function() {
478 |     var promise = new Promise();
479 |     var conn = new mysql.Connection(config.mysql.hostname, 
480 | 					  config.mysql.username,
481 | 					  config.mysql.password,
482 | 					  config.mysql.database);
483 |     helper.exceptClass(mysql.Connection, conn);
484 |     conn.connect();
485 |     conn.autocommit(false);
486 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER, str VARCHAR(254), PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci' Type=InnoDB");
487 |     conn.query("BEGIN");
488 |     conn.query("INSERT INTO t VALUES (1,'abc')");
489 |     conn.query("COMMIT");
490 |     // execute SELECT query
491 |     helper.expect_callback();
492 |     conn.query('SELECT * FROM t ORDER BY id', function(result) { // Success
493 | 	helper.was_called_back();
494 | 	
495 | 	assert.equal(1, result.records.length);
496 | 	assert.equal(1, result.records[0][0]);
497 | 	assert.equal('abc', result.records[0][1]);
498 | 
499 | 	conn.close();
500 | 	promise.emitSuccess();
501 |     });
502 |     return promise;
503 | }
504 | all_tests.push(["test_transaction1", test_transaction1]);
505 | 
506 | 
507 | var test_transaction2 = function() {
508 |     var promise = new Promise();
509 |     var conn = new mysql.Connection(config.mysql.hostname, 
510 | 					  config.mysql.username,
511 | 					  config.mysql.password,
512 | 					  config.mysql.database);
513 |     helper.exceptClass(mysql.Connection, conn);
514 |     conn.connect();
515 |     conn.autocommit(false);
516 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER, str VARCHAR(254), PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci' Type=InnoDB");
517 |     conn.query("BEGIN");
518 |     conn.query("INSERT INTO t VALUES (1,'abc')");
519 |     conn.query("ROLLBACK");
520 |     // execute SELECT query
521 |     helper.expect_callback();
522 |     conn.query('SELECT * FROM t ORDER BY id', function(result) { // Success
523 | 	helper.was_called_back();
524 | 	assert.equal(0, result.records.length);
525 | 	conn.close();
526 | 	promise.emitSuccess();
527 |     });
528 |     return promise;
529 | }
530 | all_tests.push(["test_transaction2", test_transaction2]);
531 | 
532 | 
533 | var test_error = function() {
534 |     var promise = new Promise();
535 |     var conn = new mysql.Connection(config.mysql.hostname, 
536 | 					  config.mysql.username,
537 | 					  config.mysql.password,
538 | 					  config.mysql.database);
539 |     helper.exceptClass(mysql.Connection, conn);
540 |     conn.connect();
541 |     helper.expect_callback();
542 |     conn.query('ERROR STATEMENT',
543 | 	       function(result) {
544 | 		   promise.emitError();
545 | 	       },
546 | 	       function(error) {
547 | 		   helper.was_called_back();
548 | 		   sys.puts(error);
549 | 		   conn.close();
550 | 		   promise.emitSuccess();
551 | 	       });
552 |     return promise;
553 | }
554 | all_tests.push(["test_error", test_error]);
555 | 
556 | 
557 | var test_defaultError = function() {
558 |     var promise = new Promise();
559 |     var conn = new mysql.Connection(config.mysql.hostname, 
560 | 					  config.mysql.username,
561 | 					  config.mysql.password,
562 | 					  config.mysql.database);
563 |     helper.exceptClass(mysql.Connection, conn);
564 |     conn.connect();
565 |     conn.defaultErrback = function(error) {
566 | 	helper.was_called_back();
567 | 	sys.puts(error);
568 | 	conn.close();
569 | 	promise.emitSuccess();
570 |     };
571 |     
572 |     helper.expect_callback();
573 |     conn.query('ERROR STATEMENT',
574 | 	       function(result) {
575 | 		   promise.emitError();
576 | 	       });
577 |     return promise;
578 | }
579 | all_tests.push(["test_defaultError", test_defaultError]);
580 | 
581 | 
582 | var test_statements_type = function(sql_type, value, assert_value_or_callback) {
583 |     return function() {
584 | 	var promise = new Promise();
585 | 	var conn = new mysql.Connection(config.mysql.hostname, 
586 | 					config.mysql.username,
587 | 					config.mysql.password,
588 | 					config.mysql.database);
589 | 	helper.exceptClass(mysql.Connection, conn);
590 | 	conn.connect();
591 | 	conn.query("CREATE TEMPORARY TABLE t (id INTEGER, val "+sql_type+", PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci' ENGINE=InnoDB");
592 | 	
593 | 	// regular query
594 | 	helper.expect_callback();
595 | 	conn.query("INSERT INTO t VALUE (1,'"+mysql.quote(value)+"')", function(result) {
596 | 	    helper.was_called_back();
597 | 	    // verify inserted data
598 | 	    helper.expect_callback();
599 | 	    conn.query('SELECT * FROM t ORDER BY id', function(result) {
600 | 		helper.was_called_back();
601 | 		
602 | 		// result data
603 | 		assert.equal(1, result.records.length);
604 | 		assert.equal(1, result.records[0][0]);
605 | 		if(typeof(assert_value_or_callback)=='undefined') {
606 | 		    assert.equal(value, result.records[0][1]);
607 | 		}
608 | 		else if(typeof(assert_value_or_callback)=='function') {
609 | 		    assert_value_or_callback(result.records[0][1]);
610 | 		}
611 | 		else {
612 | 		    assert.equal(assert_value_or_callback, result.records[0][1]);
613 | 		}
614 | 		conn.close();
615 | 		promise.emitSuccess();
616 | 	    },
617 |             function(error){ assert.ok(true, false); });
618 | 	},
619 |         function(error){ assert.ok(true, false); });
620 | 	return promise
621 |     };
622 | }
623 | 
624 | var test_prepared_statements_type = function(sql_type, value, assert_value_or_callback) {
625 |     return function() {
626 | 	var promise = new Promise();
627 | 	var conn = new mysql.Connection(config.mysql.hostname, 
628 | 					config.mysql.username,
629 | 					config.mysql.password,
630 | 					config.mysql.database);
631 | 	helper.exceptClass(mysql.Connection, conn);
632 | 	conn.connect();
633 | 	conn.query("CREATE TEMPORARY TABLE t (id INTEGER, val "+sql_type+", PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
634 | 	
635 | 	// prepared statement
636 | 	helper.expect_callback();
637 | 	conn.prepare('INSERT INTO t VALUE (?,?)', function(stmt) {
638 | 	    helper.was_called_back();
639 | 	    stmt.execute([1, value], helper.scope(this,function(result) {
640 | 		// verify inserted data
641 | 		
642 | 		helper.expect_callback();
643 | 		conn.query('SELECT * FROM t ORDER BY id', function(result) {
644 | 		    helper.was_called_back();
645 | 		    
646 | 		    // result data
647 | 		    assert.equal(1, result.records.length);
648 | 		    assert.equal(1, result.records[0][0]);
649 | 		    if(typeof(assert_value_or_callback)=='undefined') {
650 | 			assert.equal(value, result.records[0][1]);
651 | 		    }
652 | 		    else if(typeof(assert_value_or_callback)=='function') {
653 | 			assert.equal(true, assert_value_or_callback(result.records[0][1]));
654 | 		    }
655 | 		    else {
656 | 			assert.equal(assert_value_or_callback, result.records[0][1]);
657 | 		    }
658 | 		    
659 | 		    helper.expect_callback();
660 | 		    conn.prepare('SELECT * FROM t WHERE id=?', function(stmt) {
661 | 			helper.was_called_back();
662 | 			helper.expect_callback();
663 | 			stmt.execute([1], function(result) {
664 | 			    helper.was_called_back();
665 | 			    assert.equal(1, result.records.length);
666 | 			    assert.equal(1, result.records[0][0]);
667 | 			    if(typeof(assert_value_or_callback)=='undefined') {
668 | 				assert.equal(value, result.records[0][1]);
669 | 			    }
670 | 			    else if(typeof(assert_value_or_callback)=='function') {
671 | 				assert.equal(true, assert_value_or_callback(result.records[0][1]));
672 | 			    }
673 | 			    else {
674 | 				assert.equal(assert_value_or_callback, result.records[0][1]);
675 | 			    }
676 | 			    conn.close();
677 | 			    promise.emitSuccess();
678 | 			},
679 | 		        function(error){ assert.ok(true, false); });
680 | 		    },
681 | 		    function(error){ assert.ok(true, false); });
682 | 		},
683 | 	        function(error){ assert.ok(true, false); });
684 | 	    }),
685 | 	    function(error){ assert.ok(true, false); });
686 | 	},
687 | 	function(error){ assert.ok(true, false); });
688 | 	return promise
689 |     };
690 | }
691 | 
692 | var test_type = function(test_suite, sql_type, value, text_value, assert_value_or_callback) {
693 |     test_suite.push(["Type "+sql_type+": "+sys.inspect(text_value), function() {
694 | 	var promise = new Promise();
695 | 	test_statements_type(sql_type, text_value, assert_value_or_callback)()
696 | 	    .addCallback(function() {
697 | 		test_prepared_statements_type(sql_type, value, assert_value_or_callback)()
698 | 		    .addCallback(function() {
699 | 			promise.emitSuccess()
700 | 		    });
701 | 	    });
702 | 	return promise
703 |     }]);
704 | }
705 | 
706 | // String types
707 | test_type(all_tests, 'TEXT', 'abcdef', 'abcdef');
708 | test_type(all_tests, 'TEXT', "\u3042\u3044\u3046\u3048\u304A", "\u3042\u3044\u3046\u3048\u304A");
709 | 
710 | test_type(all_tests, 'VARCHAR(10)', 'abcdef', 'abcdef');
711 | test_type(all_tests, 'VARCHAR(10)', "\u3042\u3044\u3046\u3048\u304A", "\u3042\u3044\u3046\u3048\u304A");
712 | test_type(all_tests, 'VARCHAR(5)', 'abcdef', 'abcdef', 'abcde');
713 | test_type(all_tests, 'CHAR(10)', 'abcdef', 'abcdef');
714 | test_type(all_tests, 'CHAR(10)', "\u3042\u3044\u3046\u3048\u304A", "\u3042\u3044\u3046\u3048\u304A");
715 | 
716 | test_type(all_tests, 'BLOB', 'abcdef', 'abcdef');
717 | test_type(all_tests, 'ENUM("a","b","c")', 'a', 'a');
718 | test_type(all_tests, 'ENUM("a","b","c")', 'z', 'z', '');
719 | test_type(all_tests, 'ENUM("a","b","c","\u3042")', "\u3042", "\u3042");
720 | test_type(all_tests, 'SET("a","b","c")', 'a,b', 'a,b');
721 | test_type(all_tests, 'SET("a","b","c")', 'a,b,z', 'a,b,z', 'a,b');
722 | test_type(all_tests, 'SET("a","b","c","\u3042")', 'a,b,\u3042', 'a,b,\u3042', 'a,b,\u3042');
723 | 
724 | // Number types
725 | test_type(all_tests, 'INTEGER', 12345, "12345");
726 | test_type(all_tests, 'INTEGER', -12345, "-12345");
727 | test_type(all_tests, 'INTEGER UNSIGNED', -12345, "-12345", 0);
728 | test_type(all_tests, 'INTEGER', 12345, "12345");
729 | test_type(all_tests, 'BIGINT', 12345, "12345");
730 | test_type(all_tests, 'MEDIUMINT', 12345, "12345");
731 | test_type(all_tests, 'SMALLINT', 12345, "12345");
732 | test_type(all_tests, 'TINYINT', 123, "123");
733 | test_type(all_tests, 'TINYINT', 12345, "12345", 127);
734 | test_type(all_tests, 'DECIMAL', 1234, "1234");
735 | test_type(all_tests, 'DECIMAL', -1234, "-1234");
736 | test_type(all_tests, 'FLOAT', 1.5, "1.5");
737 | test_type(all_tests, 'FLOAT', 1234.0, "1234.0");
738 | test_type(all_tests, 'FLOAT', 1234.5, "1234.5");
739 | test_type(all_tests, 'FLOAT', -1234.5, "-1234.5");
740 | test_type(all_tests, 'REAL', 1234.5, "1234.5");
741 | test_type(all_tests, 'REAL', -1234.5, "-1234.5");
742 | test_type(all_tests, 'DOUBLE', 1234.567, "1234.567");
743 | test_type(all_tests, 'DOUBLE', 1234567.89, "1234567.89");
744 | test_type(all_tests, 'DOUBLE', -1234567.89, "-1234567.89");
745 | 
746 | // Date types
747 | test_type(all_tests, 'DATE', new mysql.Time(1976,2,8), "1976-2-8", function(v){return v.year==1976 && v.month==2 && v.day==8});
748 | test_type(all_tests, 'DATE', new mysql.Time(0,0,0), "0-0-0", function(v){return v.year==0 && v.month==0 && v.day==0});
749 | test_type(all_tests, 'DATE', new mysql.Time(1976,2,8,12,34,56), "1976-2-8 12:34:56", function(v){return v.year==1976 && v.month==2 && v.day==8 && v.hour==0 && v.minute==0 && v.second==0;});
750 | test_type(all_tests, 'TIMESTAMP', new mysql.Time(1976,2,8,12,34,56), "1976-2-8 12:34:56", function(v){return v.year==1976 && v.month==2 && v.day==8 && v.hour==12 && v.minute==34 && v.second==56;});
751 | test_type(all_tests, 'DATETIME', new mysql.Time(1976,2,8,12,34,56), "1976-2-8 12:34:56", function(v){return v.year==1976 && v.month==2 && v.day==8 && v.hour==12 && v.minute==34 && v.second==56});
752 | test_type(all_tests, 'TIME', new mysql.Time(0,0,0,12,34,56), "12:34:56", function(v){return v.year==0 && v.month==0 && v.day==0 && v.hour==12 && v.minute==34 && v.second==56});
753 | test_type(all_tests, 'TIME', new mysql.Time(0,0,8,12,34,56), "8 12:34:56", function(v){return v.year==0 && v.month==0 && v.day==0 && v.hour==204 && v.minute==34 && v.second==56});
754 | 
755 | 
756 | var test_load_localfile = function() {
757 |     var promise = new Promise();
758 |     var conn = new mysql.Connection(config.mysql.hostname, 
759 | 					  config.mysql.username,
760 | 					  config.mysql.password,
761 | 					  config.mysql.database);
762 |     helper.exceptClass(mysql.Connection, conn);
763 |     conn.local_infile = true;
764 |     conn.connect();
765 |     conn.query("CREATE TEMPORARY TABLE t (id INTEGER, str VARCHAR(254), PRIMARY KEY (id)) CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'");
766 |     var filename = __dirname + "/fixtures/data1.csv";
767 |     conn.query("LOAD DATA LOCAL INFILE '"+mysql.quote(filename)+"' INTO TABLE t",undefined, function(e){sys.puts(sys.inspect(e));});
768 |     
769 |     // execute SELECT query
770 |     helper.expect_callback();
771 |     conn.query('SELECT * FROM t ORDER BY id',
772 | 	       function(result) { // Success
773 | 		   helper.was_called_back();
774 | 
775 | 		   // field information
776 | 		   assert.equal(2, result.fields.length);
777 | 		   
778 | 		   // result data
779 | 		   assert.equal(2, result.records.length);
780 | 		   assert.equal(1, result.records[0][0]);
781 | 		   assert.equal('abc', result.records[0][1]);
782 | 		   assert.equal(2, result.records[1][0]);
783 | 		   assert.equal('def', result.records[1][1]);
784 | 		   conn.close();
785 | 		   promise.emitSuccess();
786 | 	       },
787 | 	       function(error){ assert.ok(true, false); });
788 |     return promise;
789 | }
790 | all_tests.push(["test_load_localfile", test_load_localfile]);
791 | 
792 | helper.run(all_tests);
793 | 
794 | /*
795 | node-mysql
796 | A node.js interface for MySQL
797 | 
798 | Author: masuidrive <masui@masuidrive.jp>
799 | License: MIT License
800 | Copyright (c) Yuichiro MASUI
801 | */
802 | 


--------------------------------------------------------------------------------
/test/test.stub.js:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | GLOBAL.DEBUG = true;
  3 | var events = require("events");
  4 | var sys = require("sys");
  5 | var assert = require("assert");
  6 | 
  7 | var helper = require('./helper');
  8 | var config = require('./config');
  9 | var mysql = require('../lib/mysql');
 10 | var Promise = require('../lib/mysql/node-promise').Promise;
 11 | 
 12 | var all_tests = [];
 13 | 
 14 | var test_protocolVersion11 = function() {
 15 |     var promise = new Promise();
 16 |     var conn = helper.createMockConnection(mysql, "protocol version 11");
 17 |     helper.expect_callback();
 18 |     conn.connect(
 19 | 	function() {
 20 | 	    assert.ok(true, false);
 21 | 	    conn.close();
 22 | 	    promise.emitError();
 23 | 	},
 24 | 	function(error) {
 25 | 	    helper.was_called_back();
 26 | 	    assert.equal("Don't support protocol version 11", error.message);
 27 | 	    conn.close();
 28 | 	    promise.emitSuccess();
 29 | 	}
 30 |     );
 31 |     return promise
 32 | };
 33 | all_tests.push(["protocol version 11", test_protocolVersion11]);
 34 | 
 35 | 
 36 | var test_queryTimeout = function() {
 37 |     var promise = new Promise();
 38 |     var conn = helper.createMockConnection(mysql, "query timeout");
 39 |     conn.timeout(1000);
 40 |     helper.expect_callback();
 41 |     conn.connect(
 42 | 	function() {
 43 | 	    helper.was_called_back();
 44 | 	    helper.expect_callback();
 45 | 	    conn.query('SELECT 1.23',
 46 | 		       function() {
 47 | 			   assert.ok(true, false);
 48 | 			   conn.close();
 49 | 			   promise.emitError();
 50 | 		       },
 51 | 		       function(error) {
 52 | 			   helper.was_called_back();
 53 | 			   assert.equal('connection timeout', error.message);
 54 | 			   conn.close();
 55 | 			   promise.emitSuccess();
 56 | 		       });
 57 | 	},
 58 | 	function(error) {
 59 | 	    assert.ok(true, false);
 60 | 	    conn.close();
 61 | 	    promise.emitError();
 62 | 	});
 63 |     return promise
 64 | };
 65 | all_tests.push(["query timeout", test_queryTimeout]);
 66 | 
 67 | 
 68 | var test_authenticationTimeout = function() {
 69 |     var promise = new Promise();
 70 |     var conn = helper.createMockConnection(mysql, "authentication timeout");
 71 |     conn.timeout(1000);
 72 |     helper.expect_callback();
 73 |     conn.connect(
 74 | 	function() {
 75 | 	    assert.ok(true, false);
 76 | 	    conn.close();
 77 | 	    promise.emitError();
 78 | 	},
 79 | 	function(error) {
 80 | 	    helper.was_called_back();
 81 |   	    assert.equal('connection timeout', error.message);
 82 | 	    conn.close();
 83 | 	    promise.emitSuccess();
 84 | 	}
 85 |     );
 86 |     return promise
 87 | };
 88 | all_tests.push(["authentication timeout", test_authenticationTimeout]);
 89 | 
 90 | 
 91 | var test_shutdownOnAuthentication = function() {
 92 |     var promise = new Promise();
 93 |     var conn = helper.createMockConnection(mysql, "shutdown on authentication");
 94 |     conn.timeout(1000);
 95 |     helper.expect_callback();
 96 |     conn.connect(
 97 | 	function() {
 98 | 	    assert.ok(true, false);
 99 | 	    conn.close();
100 | 	    promise.emitError();
101 | 	},
102 | 	function(error) {
103 | 	    helper.was_called_back();
104 | 	    assert.ok('connection was closed', error.message);
105 | 	    conn.close();
106 | 	    promise.emitSuccess();
107 | 	}
108 |     );
109 |     return promise
110 | };
111 | all_tests.push(["shutdown on authentication", test_shutdownOnAuthentication]);
112 | 
113 | 
114 | helper.run(all_tests);
115 | 
116 | /*
117 | node-mysql
118 | A node.js interface for MySQL
119 | 
120 | Author: masuidrive <masui@masuidrive.jp>
121 | License: MIT License
122 | Copyright (c) Yuichiro MASUI
123 | */
124 | 


--------------------------------------------------------------------------------