Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit 789a6864 by Sascha Depold
Options

removed node-mysql and added nodejs-mysql-native

1 parent d57a18f2
Inline Side-by-side
Showing with 0 additions and 3753 deletions
lib/node-mysql/mysql.js deleted 100644 → 0
/*
node-mysql
node-mysql is pure Javascript MySQL network driver for [node.js](http://nodejs.org/)
*/
var sys = require('sys');
var events = require('events');
var result = require('./mysql/result');
var types = require('./mysql/types');
var utils = require('./mysql/utils');
var errors = require('./mysql/errors');
var Promise = require('./mysql/node-promise').Promise;
var Protocol = require('./mysql/protocol').Protocol;
var constants = require('./mysql/constants')
exports.constants = constants;
exports.Time = types.Time;
exports.quote = types.quote;
exports.constants = constants;
var Connection = function(hostname, username, password, dbname, port) {
events.EventEmitter.call(this);
this.protocol = undefined;
this.active = false;
this.connect_parameter = Array.prototype.slice.call(arguments);
this.last_error = undefined;
this.sqlstate = undefined;
this._timeout = undefined;
this.defaultErrback = function(error) {
sys.puts("MySQL error: "+error);
}
}
sys.inherits(Connection, events.EventEmitter);
exports.Connection = Connection;
Connection.prototype.connect = function(callback, errback) {
this.protocol = new Protocol(this.connect_parameter[0], this.connect_parameter[4]);
if(this._timeout) this.protocol.timeout(this._timeout);
this.protocol.addListener('connect', utils.scope(this, function() {
this.active = false;
this.emit('connect');
this.protocol.authenticate(this.connect_parameter[1],
this.connect_parameter[2],
this.connect_parameter[3],
(this.local_infile ? constants.client.LOCAL_FILES : 0),
'utf8_general_ci'
)
.addCallback(callback)
.addErrback(errback || this.defaultErrback);
}));
this.protocol.addListener('close', utils.scope(this, function() {
this.active = false;
this.emit('close');
}));
this.protocol.addListener('authorized', utils.scope(this, function() {
this.active = true;
this.emit('authorized');
}));
this.protocol.addListener('authorize error', utils.scope(this, function() {
this.active = false;
this.emit('authorize error');
}));
}
Connection.prototype.close = function() {
this.protocol.close();
}
Connection.prototype.timeout = function(msec) {
if(msec) {
this._timeout = msec;
if(this.protocol) this.protocol.timeout(this._timeout);
}
return this._timeout;
}
// Set autocommit mode
Connection.prototype.autocommit = function(flag, callback, errback) {
this.query("set autocommit="+(flag ? "1" : "0"), callback, (errback || this.defaultErrback));
}
Connection.prototype.query = function(sql, callback, errback) {
var sql = this.extract_placeholder(sql);
if(sql.constructor==errors.ClientError.prototype.constructor) {
(errback || this.defaultErrback)(sql);
return;
}
this.protocol.query_command(sql)
.addCallback(utils.scope(this, function(nfields) {
if(nfields) {
this.protocol.retr_fields(nfields)
.addCallback(utils.scope(this, function(fields) {
this.fields = fields;
this.get_result()
.addCallback(utils.scope(this, function(rows) {
this.server_status = this.protocol.server_status;
try {
if(callback) callback(rows);
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}))
.addErrback(errback || this.defaultErrback);
}))
.addErrback(errback || this.defaultErrback);
}
else {
var result = {};
result.affected_rows = this.affected_rows = this.protocol.affected_rows;
result.insert_id = this.insert_id = this.protocol.insert_id;
result.server_status = this.server_status = this.protocol.server_status;
result.warning_count = this.warning_count = this.protocol.warning_count;
result.info = this.info = this.protocol.message;
try {
if(callback) callback(result);
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}
}))
.addErrback(errback || this.defaultErrback);
}
Connection.prototype.extract_placeholder = function(sql) {
if(typeof(sql)=='string') return sql;
var format = sql[0];
var bind = sql.slice(1).map(function(v) {
return types.convertToSQLString(v);
});
if(format.match(/\?/g).length!=bind.length) {
return new errors.ClientError('parameter count mismatch');
}
return format.replace(/\?/g, function() {
return bind.shift();
});
}
Connection.prototype.set_server_option = function(opt) {
return this.protocol.set_option_command(opt);
}
Connection.prototype.get_result = function(fields) {
var res = new result.Result(this.fields.map(function(field) {
return(new Field(field));
}), this.protocol);
return res.fetch_all();
}
Connection.prototype.has_more_results = function() {
return !!(this.protocol.server_status & constants.server.MORE_RESULTS_EXISTS);
}
Connection.prototype.next_result = function(callback, errback) {
if(!this.has_more_results()) {
process.nextTick(new Error("ClientError", "Don't have more results"));
return;
}
this.protocol.get_result()
.addCallback(utils.scope(this, function(nfields) {
this.protocol.retr_fields(nfields)
.addCallback(utils.scope(this, function(fields) {
this.fields = fields;
this.result_exist = true;
this.get_result()
.addCallback(utils.scope(this, function(results) {
try {
if(callback) callback(results);
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}))
.addErrback(errback || this.defaultErrback);
}))
.addErrback(errback || this.defaultErrback);
}))
.addErrback(errback || this.defaultErrback);
}
Connection.prototype.prepare = function(str, callback, errback) {
var stmt = new Stmt(this.protocol, this.charset);
return stmt.prepare(str, callback, (errback || this.defaultErrback));
};
var Stmt = function(protocol, charset) {
this.protocol = protocol;
this.charset = charset;
this.statement_id = undefined;
this.affected_rows = this.insert_id = this.server_status = this.warning_count = 0;
this.sqlstate = "00000";
this.param_count = undefined;
}
Stmt.prototype.close = function() {
this.protocol.stmt_close_command(this.statement_id);
this.statement_id = undefined;
this.param_count = undefined;
}
Stmt.prototype.prepare = function(query, callback, errback) {
this.close();
this.protocol.stmt_prepare_command(query)
.addCallback(utils.scope(this, function(statement_id, param_count, field_packets) {
this.statement_id = statement_id;
this.sqlstate = "00000";
this.param_count = param_count;
this.fields = field_packets.map(function(field_packet) {
return new Field(field_packet);
});
try {
if(callback) callback(this);
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}))
.addErrback(errback || this.defaultErrback);
}
Stmt.prototype.execute = function(args, callback, errback) {
if(typeof(this.param_count)=='undefined') {
errback(new errors.ClientError("not prepared"));
return;
}
if(this.param_count!=args.length) {
errback(new errors.ClientError("parameter count mismatch"));
return;
}
this.sqlstate = "00000";
this.protocol.stmt_execute_command(this.statement_id, args)
.addCallback(utils.scope(this, function(nfields) {
if(typeof(nfields)!='undefined') {
this.protocol.retr_fields(nfields)
.addCallback(utils.scope(this, function(fields) {
this.fields = fields;
this.result = new result.StatementResult(this.fields, this.protocol);
this.protocol.stmt_retr_all_records(fields, this.charset)
.addCallback(utils.scope(this, function(records) {
this.result.records = records;
try {
callback(this.result);
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}))
.addErrback(errback || this.defaultErrback);
}))
.addErrback(errback || this.defaultErrback);
}
else {
this.affected_rows = this.protocol.affected_rows;
this.insert_id = this.protocol.insert_id;
this.server_status = this.protocol.server_status;
this.warning_count = this.protocol.warning_count;
this.info = this.protocol.message;
try {
callback();
}
catch(error) {
(errback || this.defaultErrback)(error);
}
}
}))
.addErrback(errback || this.defaultErrback);
}
var Field = function(packet) {
this.db = packet.db;
this.table = packet.table;
this.org_table = packet.org_table;
this.name = packet.name;
this.org_name = packet.org_name;
this.charsetnr = packet.charsetnr;
this.length = packet.length;
this.type = packet.type;
this.flags = packet.flags;
this.decimals = packet.decimals;
this.defaultVal = packet.defaultVal;
}
exports.Field = Field;
Field.prototype.is_num = function() {
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;
}
Field.prototype.is_not_null = function() {
return !!(this.flags & constants.field.NOT_NULL_FLAG);
}
Field.prototype.is_pri_key = function() {
return !!(this.flags & constants.field.PRI_KEY_FLAG);
}
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/auth.js deleted 100644 → 0
var sha1;
try {
var crypto = require('crypto');
sha1 = function(message) {
return (new crypto.Hash).init("sha1").update(message).digest();
}
}
catch(e) {
var SHA1 = require('./sha1').SHA1;
var i32tostr = function(i32) {
var ret = '';
for (var i=0; i<4; ++i) {
v = i32 & 0xff;
i32 >>>= 8;
ret = String.fromCharCode(v) + ret;
}
return ret;
};
sha1 = function(message) {
var digest = new SHA1(message).digest();
var ret = "";
for(var i=0; i<digest.length; ++i) {
ret += i32tostr(digest[i]);
}
return ret;
}
}
exports.encrypt_password = function(plain, scramble) {
var stage1 = sha1(plain);
var stage2 = sha1(scramble+sha1(stage1));
var result = "";
for(var i=0; i<stage1.length; ++i) {
result += String.fromCharCode(stage1.charCodeAt(i) ^ stage2.charCodeAt(i));
}
return(result);
}
/*
node-mysql
A node.js interface for MySQL
http://github.com/masuidrive/node-mysql
Copyright (c) Yuichiro MASUI <masui@masuidrive.jp>
License: MIT License
*/
lib/node-mysql/mysql/charset.js deleted 100644 → 0
var sys=require('sys');
exports.Charset = function(number, name, csname) {
this.number = number;
this.name = name;
this.csname = csname;
if(this.name=='utf8') {
this.convertToBytes = convertUTF8ToBytes;
this.convertFromBytes = convertUTF8FromBytes;
}
}
exports.Charset.by_number = function(n) {
for(var i=0; i<charset.length; ++i) {
if(n==charset[i][0])
return(new exports.Charset(charset[i][0], charset[i][1], charset[i][2]));
}
return undefined;
}
exports.Charset.by_name = function(n) {
for(var i=0; i<charset.length; ++i) {
if(n==charset[i][2])
return(new exports.Charset(charset[i][0], charset[i][1], charset[i][2]));
}
return undefined;
}
exports.Charset.prototype.convertToBytes = function(str) {
return str;
}
exports.Charset.prototype.convertFromBytes = function(bytes) {
return bytes;
}
// "あい" => "\xE3\x81\x82\xE3\x81\x84" // UTF-8
var convertUTF8ToBytes = function(str) {
if(typeof(str)=='undefined') return undefined;
if(typeof(str)=='undefined') return undefined;
var surrogate_1st = 0;
var unicode_codes = [];
for (var i = 0; i < str.length; ++i) {
var utf16_code = str.charCodeAt(i);
if (surrogate_1st != 0) {
if (utf16_code >= 0xdc00 && utf16_code <= 0xdfff) {
var surrogate_2nd = utf16_code;
var unicode_code = (surrogate_1st - 0xd800) * (1 << 10) + (1 << 16) +
(surrogate_2nd - 0xdc00);
unicode_codes.push(unicode_code);
}
surrogate_1st = 0;
}
else if (utf16_code >= 0xd800 && utf16_code <= 0xdbff) {
surrogate_1st = utf16_code;
}
else {
unicode_codes.push(utf16_code);
}
}
var utf8_bytes = "";
var i, unicode_code;
for(i=0; i<unicode_codes.length; ++i) {
unicode_code = unicode_codes[i];
if (unicode_code < 0x80) { // 1-byte
utf8_bytes += String.fromCharCode(unicode_code);
}
else if (unicode_code < (1 << 11)) { // 2-byte
utf8_bytes += String.fromCharCode((unicode_code >>> 6) | 0xC0);
utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
}
else if (unicode_code < (1 << 16)) { // 3-byte
utf8_bytes += String.fromCharCode((unicode_code >>> 12) | 0xE0);
utf8_bytes += String.fromCharCode(((unicode_code >> 6) & 0x3f) | 0x80);
utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
}
else if (unicode_code < (1 << 21)) { // 4-byte
utf8_bytes += String.fromCharCode((unicode_code >>> 18) | 0xF0);
utf8_bytes += String.fromCharCode(((unicode_code >> 12) & 0x3F) | 0x80);
utf8_bytes += String.fromCharCode(((unicode_code >> 6) & 0x3F) | 0x80);
utf8_bytes += String.fromCharCode((unicode_code & 0x3F) | 0x80);
}
}
return utf8_bytes;
}
var convertUTF8FromBytes = function(str) {
if(typeof(str)=='undefined') return undefined;
var unicode_str = "";
var unicode_code = 0;
var num_followed = 0;
var utf8_byte;
for (var i = 0; i < str.length; ++i) {
utf8_byte = str.charCodeAt(i)
if (utf8_byte >= 0x100) {
// Malformed utf8 byte ignored.
}
else if ((utf8_byte & 0xc0) == 0x80) {
if (num_followed > 0) {
unicode_code = (unicode_code << 6) | (utf8_byte & 0x3f);
num_followed -= 1;
} else {
// Malformed UTF-8 sequence ignored.
}
}
else {
if (num_followed == 0) {
unicode_str += String.fromCharCode(unicode_code);
}
else {
// Malformed UTF-8 sequence ignored.
}
if (utf8_byte < 0x80){ // 1-byte
unicode_code = utf8_byte;
num_followed = 0;
} else if ((utf8_byte & 0xe0) == 0xc0) { // 2-byte
unicode_code = utf8_byte & 0x1f;
num_followed = 1;
} else if ((utf8_byte & 0xf0) == 0xe0) { // 3-byte
unicode_code = utf8_byte & 0x0f;
num_followed = 2;
} else if ((utf8_byte & 0xf8) == 0xf0) { // 4-byte
unicode_code = utf8_byte & 0x07;
num_followed = 3;
} else {
// Malformed UTF-8 sequence ignored.
}
}
}
if (num_followed == 0) {
unicode_str += String.fromCharCode(unicode_code);
} else {
// Malformed UTF-8 sequence ignored.
}
return unicode_str.substring(1);
}
// [[charset_number, charset_name, collation_name, default], ...]
var charset = [
[ 1, "big5", "big5_chinese_ci", true ],
[ 2, "latin2", "latin2_czech_cs", false],
[ 3, "dec8", "dec8_swedish_ci", true ],
[ 4, "cp850", "cp850_general_ci", true ],
[ 5, "latin1", "latin1_german1_ci", false],
[ 6, "hp8", "hp8_english_ci", true ],
[ 7, "koi8r", "koi8r_general_ci", true ],
[ 8, "latin1", "latin1_swedish_ci", true ],
[ 9, "latin2", "latin2_general_ci", true ],
[ 10, "swe7", "swe7_swedish_ci", true ],
[ 11, "ascii", "ascii_general_ci", true ],
[ 12, "ujis", "ujis_japanese_ci", true ],
[ 13, "sjis", "sjis_japanese_ci", true ],
[ 14, "cp1251", "cp1251_bulgarian_ci", false],
[ 15, "latin1", "latin1_danish_ci", false],
[ 16, "hebrew", "hebrew_general_ci", true ],
[ 17, "filename", "filename", true ],
[ 18, "tis620", "tis620_thai_ci", true ],
[ 19, "euckr", "euckr_korean_ci", true ],
[ 20, "latin7", "latin7_estonian_cs", false],
[ 21, "latin2", "latin2_hungarian_ci", false],
[ 22, "koi8u", "koi8u_general_ci", true ],
[ 23, "cp1251", "cp1251_ukrainian_ci", false],
[ 24, "gb2312", "gb2312_chinese_ci", true ],
[ 25, "greek", "greek_general_ci", true ],
[ 26, "cp1250", "cp1250_general_ci", true ],
[ 27, "latin2", "latin2_croatian_ci", false],
[ 28, "gbk", "gbk_chinese_ci", true ],
[ 29, "cp1257", "cp1257_lithuanian_ci", false],
[ 30, "latin5", "latin5_turkish_ci", true ],
[ 31, "latin1", "latin1_german2_ci", false],
[ 32, "armscii8", "armscii8_general_ci", true ],
[ 33, "utf8", "utf8_general_ci", true ],
[ 34, "cp1250", "cp1250_czech_cs", false],
[ 35, "ucs2", "ucs2_general_ci", true ],
[ 36, "cp866", "cp866_general_ci", true ],
[ 37, "keybcs2", "keybcs2_general_ci", true ],
[ 38, "macce", "macce_general_ci", true ],
[ 39, "macroman", "macroman_general_ci", true ],
[ 40, "cp852", "cp852_general_ci", true ],
[ 41, "latin7", "latin7_general_ci", true ],
[ 42, "latin7", "latin7_general_cs", false],
[ 43, "macce", "macce_bin", false],
[ 44, "cp1250", "cp1250_croatian_ci", false],
[ 47, "latin1", "latin1_bin", false],
[ 48, "latin1", "latin1_general_ci", false],
[ 49, "latin1", "latin1_general_cs", false],
[ 50, "cp1251", "cp1251_bin", false],
[ 51, "cp1251", "cp1251_general_ci", true ],
[ 52, "cp1251", "cp1251_general_cs", false],
[ 53, "macroman", "macroman_bin", false],
[ 57, "cp1256", "cp1256_general_ci", true ],
[ 58, "cp1257", "cp1257_bin", false],
[ 59, "cp1257", "cp1257_general_ci", true ],
[ 63, "binary", "binary", true ],
[ 64, "armscii8", "armscii8_bin", false],
[ 65, "ascii", "ascii_bin", false],
[ 66, "cp1250", "cp1250_bin", false],
[ 67, "cp1256", "cp1256_bin", false],
[ 68, "cp866", "cp866_bin", false],
[ 69, "dec8", "dec8_bin", false],
[ 70, "greek", "greek_bin", false],
[ 71, "hebrew", "hebrew_bin", false],
[ 72, "hp8", "hp8_bin", false],
[ 73, "keybcs2", "keybcs2_bin", false],
[ 74, "koi8r", "koi8r_bin", false],
[ 75, "koi8u", "koi8u_bin", false],
[ 77, "latin2", "latin2_bin", false],
[ 78, "latin5", "latin5_bin", false],
[ 79, "latin7", "latin7_bin", false],
[ 80, "cp850", "cp850_bin", false],
[ 81, "cp852", "cp852_bin", false],
[ 82, "swe7", "swe7_bin", false],
[ 83, "utf8", "utf8_bin", false],
[ 84, "big5", "big5_bin", false],
[ 85, "euckr", "euckr_bin", false],
[ 86, "gb2312", "gb2312_bin", false],
[ 87, "gbk", "gbk_bin", false],
[ 88, "sjis", "sjis_bin", false],
[ 89, "tis620", "tis620_bin", false],
[ 90, "ucs2", "ucs2_bin", false],
[ 91, "ujis", "ujis_bin", false],
[ 92, "geostd8", "geostd8_general_ci", true ],
[ 93, "geostd8", "geostd8_bin", false],
[ 94, "latin1", "latin1_spanish_ci", false],
[ 95, "cp932", "cp932_japanese_ci" , true ],
[ 96, "cp932", "cp932_bin" , false],
[ 97, "eucjpms", "eucjpms_japanese_ci", true ],
[ 98, "eucjpms", "eucjpms_bin", false],
[ 99, "cp1250", "cp1250_polish_ci", false],
[128, "ucs2", "ucs2_unicode_ci", false],
[129, "ucs2", "ucs2_icelandic_ci", false],
[130, "ucs2", "ucs2_latvian_ci", false],
[131, "ucs2", "ucs2_romanian_ci", false],
[132, "ucs2", "ucs2_slovenian_ci", false],
[133, "ucs2", "ucs2_polish_ci", false],
[134, "ucs2", "ucs2_estonian_ci", false],
[135, "ucs2", "ucs2_spanish_ci", false],
[136, "ucs2", "ucs2_swedish_ci", false],
[137, "ucs2", "ucs2_turkish_ci", false],
[138, "ucs2", "ucs2_czech_ci", false],
[139, "ucs2", "ucs2_danish_ci", false],
[140, "ucs2", "ucs2_lithuanian_ci", false],
[141, "ucs2", "ucs2_slovak_ci", false],
[142, "ucs2", "ucs2_spanish2_ci", false],
[143, "ucs2", "ucs2_roman_ci", false],
[144, "ucs2", "ucs2_persian_ci", false],
[145, "ucs2", "ucs2_esperanto_ci", false],
[146, "ucs2", "ucs2_hungarian_ci", false],
[192, "utf8", "utf8_unicode_ci", false],
[193, "utf8", "utf8_icelandic_ci", false],
[194, "utf8", "utf8_latvian_ci", false],
[195, "utf8", "utf8_romanian_ci", false],
[196, "utf8", "utf8_slovenian_ci", false],
[197, "utf8", "utf8_polish_ci", false],
[198, "utf8", "utf8_estonian_ci", false],
[199, "utf8", "utf8_spanish_ci", false],
[200, "utf8", "utf8_swedish_ci", false],
[201, "utf8", "utf8_turkish_ci", false],
[202, "utf8", "utf8_czech_ci", false],
[203, "utf8", "utf8_danish_ci", false],
[204, "utf8", "utf8_lithuanian_ci", false],
[205, "utf8", "utf8_slovak_ci", false],
[206, "utf8", "utf8_spanish2_ci", false],
[207, "utf8", "utf8_roman_ci", false],
[208, "utf8", "utf8_persian_ci", false],
[209, "utf8", "utf8_esperanto_ci", false],
[210, "utf8", "utf8_hungarian_ci", false],
[254, "utf8", "utf8_general_cs", false],
];
/*
node-mysql
A node.js interface for MySQL
http://github.com/masuidrive/node-mysql
Copyright (c) Yuichiro MASUI <masui@masuidrive.jp>
License: MIT License
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/connection.js deleted 100644 → 0
// RawConnection:
// MySQL packet I/O
// http://forge.mysql.com/wiki/MySQL_Internals_ClientServer_Protocol#The_Packet_Header
var sys = require('sys');
var events = require("events");
var pack = require('./pack');
var utils = require('./utils');
var errors = require('./errors');
var Promise = require('./node-promise').Promise;
var Socket = require('./node-socket').Socket;
var MAX_PACKET_LENGTH = 16777215;
var Connection = function(port, hostname) {
events.EventEmitter.call(this);
this.hostname = hostname;
this.port = port;
this.seq = 0; // packet sequence number
this.socket = new Socket(utils.scope(this, function(){ this.emit("connect"); }),
utils.scope(this, function(){ this.emit("close"); }));
}
sys.inherits(Connection, events.EventEmitter);
exports.Connection = Connection;
// set timeout
Connection.prototype.timeout = function(timeout) {
this.socket.timeout(timeout);
}
// open TCP socket
Connection.prototype.connect = function() {
this.socket.connect(this.port, this.hostname);
}
// reset packet sequence
Connection.prototype.reset = function() {
this.seq = 0;
}
// close TCP socket
Connection.prototype.close = function() {
this.socket.close();
}
// Either "closed", "open", "opening", "readOnly", or "writeOnly".
Connection.prototype.readyState = function() {
return this.socket.readyState();
}
// Read one packet data
Connection.prototype.read = function(packet_count) {
var promise = new Promise();
var ret = "";
var len = undefined;
var packets = [];
var read_packet = utils.scope(this, function() {
try {
this.socket.read(4)
.addCallback(utils.scope(this, function(header) {
try {
var res = pack.unpack("CvC", header);
len = (res[1] << 8) + res[0];
if(res[2] != this.seq) {
promise.emitError(new errors.ProtocolError("invalid packet: sequence number mismatch("+res[2]+" != "+this.seq+"(expected))"));
return;
}
this.seq = (res[2] + 1) % 256;
this.socket.read(len)
.addCallback(utils.scope(this, function(data) {
try {
ret = ret.concat(data);
var sqlstate = "00000";
// Error packet
if(ret[0]=="\xff") {
var res = pack.unpack("Cvaa5a*", ret);
var f = res[0], errno = res[1], marker = res[2], sqlstate = res[3], message = res[4];
if(marker!="#") {
res = pack.unpack("Cva*", ret); // Version 4.0 Error
f = res[0], errno = res[1], message = res[2];
sqlstate = "";
}
promise.emitError(new errors.ServerError(message, errno, sqlstate));
}
else {
packets.push(ret);
if(typeof(packet_count)=='undefined') {
promise.emitSuccess(ret);
}
else if(packets.length>=packet_count) {
promise.emitSuccess(packets);
}
else {
read_packet();
}
}
}
catch(e) {
promise.emitError(new errors.ClientError(String(e)));
}
}))
.addErrback(utils.scope(this, function(error) {
promise.emitError(error);
}));
}
catch(e) {
promise.emitError(new errors.ClientError(String(e)));
}
}))
.addErrback(utils.scope(this, function(error) {
promise.emitError(error);
}));
}
catch(e) {
promise.emitError(new errors.ClientError(String(e)));
}
});
read_packet();
return promise;
}
// Write one packet data
Connection.prototype.write = function(data) {
try {
var promise = new Promise();
if(typeof(data)=='undefined') {
this.socket.write(pack.pack("CvC", 0, 0, this.seq));
this.seq = (this.seq + 1) % 256
promise.emitSuccess();
}
else {
var buf;
while(data) {
buf = data.substring(0, MAX_PACKET_LENGTH);
data = data.slice(MAX_PACKET_LENGTH);
this.socket.write(pack.pack("CvC", buf.length%256, buf.length/256, this.seq));
this.socket.write(buf);
this.seq = (this.seq + 1) % 256;
}
promise.emitSuccess();
}
}
catch(e) {
promise.emitError(new errors.ClientError(String(e)));
}
return promise;
}
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/constants.js deleted 100644 → 0
exports.com = {
SLEEP : 0,
QUIT : 1,
INIT_DB : 2,
QUERY : 3,
FIELD_LIST : 4,
CREATE_DB : 5,
DROP_DB : 6,
REFRESH : 7,
SHUTDOWN : 8,
STATISTICS : 9,
PROCESS_INFO : 10,
CONNECT : 11,
PROCESS_KILL : 12,
DEBUG : 13,
PING : 14,
TIME : 15,
DELAYED_INSERT : 16,
CHANGE_USER : 17,
BINLOG_DUMP : 18,
TABLE_DUMP : 19,
CONNECT_OUT : 20,
REGISTER_SLAVE : 21,
STMT_PREPARE : 22,
STMT_EXECUTE : 23,
STMT_SEND_LONG_DATA : 24,
STMT_CLOSE : 25,
STMT_RESET : 26,
SET_OPTION : 27,
STMT_FETCH : 28
};
// Client flag
exports.client = {
LONG_PASSWORD : 1, // new more secure passwords
FOUND_ROWS : 1 << 1, // Found instead of affected rows
LONG_FLAG : 1 << 2, // Get all column flags
CONNECT_WITH_DB : 1 << 3, // One can specify db on connect
NO_SCHEMA : 1 << 4, // Don't allow database.table.column
COMPRESS : 1 << 5, // Can use compression protocol
ODBC : 1 << 6, // Odbc client
LOCAL_FILES : 1 << 7, // Can use LOAD DATA LOCAL
IGNORE_SPACE : 1 << 8, // Ignore spaces before '('
PROTOCOL_41 : 1 << 9, // New 4.1 protocol
INTERACTIVE : 1 << 10, // This is an interactive client
SSL : 1 << 11, // Switch to SSL after handshake
IGNORE_SIGPIPE : 1 << 12, // IGNORE sigpipes
TRANSACTIONS : 1 << 13, // Client knows about transactions
RESERVED : 1 << 14, // Old flag for 4.1 protocol
SECURE_CONNECTION : 1 << 15, // New 4.1 authentication
MULTI_STATEMENTS : 1 << 16, // Enable/disable multi-stmt support
MULTI_RESULTS : 1 << 17 // Enable/disable multi-results
};
// Connection Option
exports.option = {
OPT_CONNECT_TIMEOUT : 0,
OPT_COMPRESS : 1,
OPT_NAMED_PIPE : 2,
INIT_COMMAND : 3,
READ_DEFAULT_FILE : 4,
READ_DEFAULT_GROUP : 5,
SET_CHARSET_DIR : 6,
SET_CHARSET_NAME : 7,
OPT_LOCAL_INFILE : 8,
OPT_PROTOCOL : 9,
SHARED_MEMORY_BASE_NAME : 10,
OPT_READ_TIMEOUT : 11,
OPT_WRITE_TIMEOUT : 12,
OPT_USE_RESULT : 13,
OPT_USE_REMOTE_CONNECTION : 14,
OPT_USE_EMBEDDED_CONNECTION : 15,
OPT_GUESS_CONNECTION : 16,
SET_CLIENT_IP : 17,
SECURE_AUTH : 18,
REPORT_DATA_TRUNCATION : 19,
OPT_RECONNECT : 20,
OPT_SSL_VERIFY_SERVER_CERT : 21,
// Server Option,
MULTI_STATEMENTS_ON : 0,
MULTI_STATEMENTS_OFF : 1
};
// Server Status
exports.server = {
STATUS_IN_TRANS : 1,
STATUS_AUTOCOMMIT : 1 << 1,
MORE_RESULTS_EXISTS : 1 << 3,
QUERY_NO_GOOD_INDEX_USED : 1 << 4,
QUERY_NO_INDEX_USED : 1 << 5,
STATUS_CURSOR_EXISTS : 1 << 6,
STATUS_LAST_ROW_SENT : 1 << 7,
STATUS_DB_DROPPED : 1 << 8,
STATUS_NO_BACKSLASH_ESCAPES : 1 << 9
};
// Refresh parameter
exports.refresh = {
GRANT : 1,
LOG : 1 << 1,
TABLES : 1 << 2,
HOSTS : 1 << 3,
STATUS : 1 << 4,
THREADS : 1 << 5,
SLAVE : 1 << 6,
MASTER : 1 << 7,
READ_LOCK : 1 << 14,
FAST : 1 << 15
};
exports.field = {
// Field type
TYPE_DECIMAL : 0,
TYPE_TINY : 1,
TYPE_SHORT : 2,
TYPE_LONG : 3,
TYPE_FLOAT : 4,
TYPE_DOUBLE : 5,
TYPE_NULL : 6,
TYPE_TIMESTAMP : 7,
TYPE_LONGLONG : 8,
TYPE_INT24 : 9,
TYPE_DATE : 10,
TYPE_TIME : 11,
TYPE_DATETIME : 12,
TYPE_YEAR : 13,
TYPE_NEWDATE : 14,
TYPE_VARCHAR : 15,
TYPE_BIT : 16,
TYPE_NEWDECIMAL : 246,
TYPE_ENUM : 247,
TYPE_SET : 248,
TYPE_TINY_BLOB : 249,
TYPE_MEDIUM_BLOB : 250,
TYPE_LONG_BLOB : 251,
TYPE_BLOB : 252,
TYPE_VAR_STRING : 253,
TYPE_STRING : 254,
TYPE_GEOMETRY : 255,
TYPE_CHAR : 1, // TYPE_TINY
TYPE_INTERVAL : 247, // TYPE_ENUM
// Flag
NOT_NULL_FLAG : 1,
PRI_KEY_FLAG : 1 << 1,
UNIQUE_KEY_FLAG : 1 << 2,
MULTIPLE_KEY_FLAG : 1 << 3,
BLOB_FLAG : 1 << 4,
UNSIGNED_FLAG : 1 << 5,
ZEROFILL_FLAG : 1 << 6,
BINARY_FLAG : 1 << 7,
ENUM_FLAG : 1 << 8,
AUTO_INCREMENT_FLAG : 1 << 9,
TIMESTAMP_FLAG : 1 << 10,
SET_FLAG : 1 << 11,
PART_KEY_FLAG : 1 << 14,
NUM_FLAG : 1 << 15,
GROUP_FLAG : 1 << 15,
UNIQUE_FLAG : 1 << 16,
BINCMP_FLAG : 1 << 17,
};
exports.stmt = {
// Cursor type
CURSOR_TYPE_NO_CURSOR : 0,
CURSOR_TYPE_READ_ONLY : 1
};
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/errors.js deleted 100644 → 0
var ClientError = function(message) {
this.message = message;
}
exports.ClientError = ClientError;
ClientError.prototype.toString = function() {
return "ClientError: "+this.message;
}
var ProtocolError = function(message) {
this.message = message;
}
exports.ProtocolError = ProtocolError;
ProtocolError.prototype.toString = function() {
return "ProtocolError: "+this.message;
}
var map = {};
var ServerError = function(message, errno, sqlstate) {
this.message = message;
this.errno = errno;
this.error_name = errno ? map[parseInt(errno)] : 'ER_UNKNOW';
this.sqlstate = sqlstate;
}
exports.ServerError = ServerError;
ServerError.prototype.toString = function() {
return "ServerError("+this.error_name+"): "+this.message+" ("+this.sqlstate+")";
}
map[0] = "ER_UNKNOW";
map[1000] = "ER_HASHCHK";
map[1001] = "ER_NISAMCHK";
map[1002] = "ER_NO";
map[1003] = "ER_YES";
map[1004] = "ER_CANT_CREATE_FILE";
map[1005] = "ER_CANT_CREATE_TABLE";
map[1006] = "ER_CANT_CREATE_DB";
map[1007] = "ER_DB_CREATE_EXISTS";
map[1008] = "ER_DB_DROP_EXISTS";
map[1009] = "ER_DB_DROP_DELETE";
map[1010] = "ER_DB_DROP_RMDIR";
map[1011] = "ER_CANT_DELETE_FILE";
map[1012] = "ER_CANT_FIND_SYSTEM_REC";
map[1013] = "ER_CANT_GET_STAT";
map[1014] = "ER_CANT_GET_WD";
map[1015] = "ER_CANT_LOCK";
map[1016] = "ER_CANT_OPEN_FILE";
map[1017] = "ER_FILE_NOT_FOUND";
map[1018] = "ER_CANT_READ_DIR";
map[1019] = "ER_CANT_SET_WD";
map[1020] = "ER_CHECKREAD";
map[1021] = "ER_DISK_FULL";
map[1022] = "ER_DUP_KEY";
map[1023] = "ER_ERROR_ON_CLOSE";
map[1024] = "ER_ERROR_ON_READ";
map[1025] = "ER_ERROR_ON_RENAME";
map[1026] = "ER_ERROR_ON_WRITE";
map[1027] = "ER_FILE_USED";
map[1028] = "ER_FILSORT_ABORT";
map[1029] = "ER_FORM_NOT_FOUND";
map[1030] = "ER_GET_ERRNO";
map[1031] = "ER_ILLEGAL_HA";
map[1032] = "ER_KEY_NOT_FOUND";
map[1033] = "ER_NOT_FORM_FILE";
map[1034] = "ER_NOT_KEYFILE";
map[1035] = "ER_OLD_KEYFILE";
map[1036] = "ER_OPEN_AS_READONLY";
map[1037] = "ER_OUTOFMEMORY";
map[1038] = "ER_OUT_OF_SORTMEMORY";
map[1039] = "ER_UNEXPECTED_EOF";
map[1040] = "ER_CON_COUNT_ERROR";
map[1041] = "ER_OUT_OF_RESOURCES";
map[1042] = "ER_BAD_HOST_ERROR";
map[1043] = "ER_HANDSHAKE_ERROR";
map[1044] = "ER_DBACCESS_DENIED_ERROR";
map[1045] = "ER_ACCESS_DENIED_ERROR";
map[1046] = "ER_NO_DB_ERROR";
map[1047] = "ER_UNKNOWN_COM_ERROR";
map[1048] = "ER_BAD_NULL_ERROR";
map[1049] = "ER_BAD_DB_ERROR";
map[1050] = "ER_TABLE_EXISTS_ERROR";
map[1051] = "ER_BAD_TABLE_ERROR";
map[1052] = "ER_NON_UNIQ_ERROR";
map[1053] = "ER_SERVER_SHUTDOWN";
map[1054] = "ER_BAD_FIELD_ERROR";
map[1055] = "ER_WRONG_FIELD_WITH_GROUP";
map[1056] = "ER_WRONG_GROUP_FIELD";
map[1057] = "ER_WRONG_SUM_SELECT";
map[1058] = "ER_WRONG_VALUE_COUNT";
map[1059] = "ER_TOO_LONG_IDENT";
map[1060] = "ER_DUP_FIELDNAME";
map[1061] = "ER_DUP_KEYNAME";
map[1062] = "ER_DUP_ENTRY";
map[1063] = "ER_WRONG_FIELD_SPEC";
map[1064] = "ER_PARSE_ERROR";
map[1065] = "ER_EMPTY_QUERY";
map[1066] = "ER_NONUNIQ_TABLE";
map[1067] = "ER_INVALID_DEFAULT";
map[1068] = "ER_MULTIPLE_PRI_KEY";
map[1069] = "ER_TOO_MANY_KEYS";
map[1070] = "ER_TOO_MANY_KEY_PARTS";
map[1071] = "ER_TOO_LONG_KEY";
map[1072] = "ER_KEY_COLUMN_DOES_NOT_EXITS";
map[1073] = "ER_BLOB_USED_AS_KEY";
map[1074] = "ER_TOO_BIG_FIELDLENGTH";
map[1075] = "ER_WRONG_AUTO_KEY";
map[1076] = "ER_READY";
map[1077] = "ER_NORMAL_SHUTDOWN";
map[1078] = "ER_GOT_SIGNAL";
map[1079] = "ER_SHUTDOWN_COMPLETE";
map[1080] = "ER_FORCING_CLOSE";
map[1081] = "ER_IPSOCK_ERROR";
map[1082] = "ER_NO_SUCH_INDEX";
map[1083] = "ER_WRONG_FIELD_TERMINATORS";
map[1084] = "ER_BLOBS_AND_NO_TERMINATED";
map[1085] = "ER_TEXTFILE_NOT_READABLE";
map[1086] = "ER_FILE_EXISTS_ERROR";
map[1087] = "ER_LOAD_INFO";
map[1088] = "ER_ALTER_INFO";
map[1089] = "ER_WRONG_SUB_KEY";
map[1090] = "ER_CANT_REMOVE_ALL_FIELDS";
map[1091] = "ER_CANT_DROP_FIELD_OR_KEY";
map[1092] = "ER_INSERT_INFO";
map[1093] = "ER_UPDATE_TABLE_USED";
map[1094] = "ER_NO_SUCH_THREAD";
map[1095] = "ER_KILL_DENIED_ERROR";
map[1096] = "ER_NO_TABLES_USED";
map[1097] = "ER_TOO_BIG_SET";
map[1098] = "ER_NO_UNIQUE_LOGFILE";
map[1099] = "ER_TABLE_NOT_LOCKED_FOR_WRITE";
map[1100] = "ER_TABLE_NOT_LOCKED";
map[1101] = "ER_BLOB_CANT_HAVE_DEFAULT";
map[1102] = "ER_WRONG_DB_NAME";
map[1103] = "ER_WRONG_TABLE_NAME";
map[1104] = "ER_TOO_BIG_SELECT";
map[1105] = "ER_UNKNOWN_ERROR";
map[1106] = "ER_UNKNOWN_PROCEDURE";
map[1107] = "ER_WRONG_PARAMCOUNT_TO_PROCEDURE";
map[1108] = "ER_WRONG_PARAMETERS_TO_PROCEDURE";
map[1109] = "ER_UNKNOWN_TABLE";
map[1110] = "ER_FIELD_SPECIFIED_TWICE";
map[1111] = "ER_INVALID_GROUP_FUNC_USE";
map[1112] = "ER_UNSUPPORTED_EXTENSION";
map[1113] = "ER_TABLE_MUST_HAVE_COLUMNS";
map[1114] = "ER_RECORD_FILE_FULL";
map[1115] = "ER_UNKNOWN_CHARACTER_SET";
map[1116] = "ER_TOO_MANY_TABLES";
map[1117] = "ER_TOO_MANY_FIELDS";
map[1118] = "ER_TOO_BIG_ROWSIZE";
map[1119] = "ER_STACK_OVERRUN";
map[1120] = "ER_WRONG_OUTER_JOIN";
map[1121] = "ER_NULL_COLUMN_IN_INDEX";
map[1122] = "ER_CANT_FIND_UDF";
map[1123] = "ER_CANT_INITIALIZE_UDF";
map[1124] = "ER_UDF_NO_PATHS";
map[1125] = "ER_UDF_EXISTS";
map[1126] = "ER_CANT_OPEN_LIBRARY";
map[1127] = "ER_CANT_FIND_DL_ENTRY";
map[1128] = "ER_FUNCTION_NOT_DEFINED";
map[1129] = "ER_HOST_IS_BLOCKED";
map[1130] = "ER_HOST_NOT_PRIVILEGED";
map[1131] = "ER_PASSWORD_ANONYMOUS_USER";
map[1132] = "ER_PASSWORD_NOT_ALLOWED";
map[1133] = "ER_PASSWORD_NO_MATCH";
map[1134] = "ER_UPDATE_INFO";
map[1135] = "ER_CANT_CREATE_THREAD";
map[1136] = "ER_WRONG_VALUE_COUNT_ON_ROW";
map[1137] = "ER_CANT_REOPEN_TABLE";
map[1138] = "ER_INVALID_USE_OF_NULL";
map[1139] = "ER_REGEXP_ERROR";
map[1140] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS";
map[1141] = "ER_NONEXISTING_GRANT";
map[1142] = "ER_TABLEACCESS_DENIED_ERROR";
map[1143] = "ER_COLUMNACCESS_DENIED_ERROR";
map[1144] = "ER_ILLEGAL_GRANT_FOR_TABLE";
map[1145] = "ER_GRANT_WRONG_HOST_OR_USER";
map[1146] = "ER_NO_SUCH_TABLE";
map[1147] = "ER_NONEXISTING_TABLE_GRANT";
map[1148] = "ER_NOT_ALLOWED_COMMAND";
map[1149] = "ER_SYNTAX_ERROR";
map[1150] = "ER_DELAYED_CANT_CHANGE_LOCK";
map[1151] = "ER_TOO_MANY_DELAYED_THREADS";
map[1152] = "ER_ABORTING_CONNECTION";
map[1153] = "ER_NET_PACKET_TOO_LARGE";
map[1154] = "ER_NET_READ_ERROR_FROM_PIPE";
map[1155] = "ER_NET_FCNTL_ERROR";
map[1156] = "ER_NET_PACKETS_OUT_OF_ORDER";
map[1157] = "ER_NET_UNCOMPRESS_ERROR";
map[1158] = "ER_NET_READ_ERROR";
map[1159] = "ER_NET_READ_INTERRUPTED";
map[1160] = "ER_NET_ERROR_ON_WRITE";
map[1161] = "ER_NET_WRITE_INTERRUPTED";
map[1162] = "ER_TOO_LONG_STRING";
map[1163] = "ER_TABLE_CANT_HANDLE_BLOB";
map[1164] = "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT";
map[1165] = "ER_DELAYED_INSERT_TABLE_LOCKED";
map[1166] = "ER_WRONG_COLUMN_NAME";
map[1167] = "ER_WRONG_KEY_COLUMN";
map[1168] = "ER_WRONG_MRG_TABLE";
map[1169] = "ER_DUP_UNIQUE";
map[1170] = "ER_BLOB_KEY_WITHOUT_LENGTH";
map[1171] = "ER_PRIMARY_CANT_HAVE_NULL";
map[1172] = "ER_TOO_MANY_ROWS";
map[1173] = "ER_REQUIRES_PRIMARY_KEY";
map[1174] = "ER_NO_RAID_COMPILED";
map[1175] = "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE";
map[1176] = "ER_KEY_DOES_NOT_EXITS";
map[1177] = "ER_CHECK_NO_SUCH_TABLE";
map[1178] = "ER_CHECK_NOT_IMPLEMENTED";
map[1179] = "ER_CANT_DO_THIS_DURING_AN_TRANSACTION";
map[1180] = "ER_ERROR_DURING_COMMIT";
map[1181] = "ER_ERROR_DURING_ROLLBACK";
map[1182] = "ER_ERROR_DURING_FLUSH_LOGS";
map[1183] = "ER_ERROR_DURING_CHECKPOINT";
map[1184] = "ER_NEW_ABORTING_CONNECTION";
map[1185] = "ER_DUMP_NOT_IMPLEMENTED";
map[1186] = "ER_FLUSH_MASTER_BINLOG_CLOSED";
map[1187] = "ER_INDEX_REBUILD";
map[1188] = "ER_MASTER";
map[1189] = "ER_MASTER_NET_READ";
map[1190] = "ER_MASTER_NET_WRITE";
map[1191] = "ER_FT_MATCHING_KEY_NOT_FOUND";
map[1192] = "ER_LOCK_OR_ACTIVE_TRANSACTION";
map[1193] = "ER_UNKNOWN_SYSTEM_VARIABLE";
map[1194] = "ER_CRASHED_ON_USAGE";
map[1195] = "ER_CRASHED_ON_REPAIR";
map[1196] = "ER_WARNING_NOT_COMPLETE_ROLLBACK";
map[1197] = "ER_TRANS_CACHE_FULL";
map[1198] = "ER_SLAVE_MUST_STOP";
map[1199] = "ER_SLAVE_NOT_RUNNING";
map[1200] = "ER_BAD_SLAVE";
map[1201] = "ER_MASTER_INFO";
map[1202] = "ER_SLAVE_THREAD";
map[1203] = "ER_TOO_MANY_USER_CONNECTIONS";
map[1204] = "ER_SET_CONSTANTS_ONLY";
map[1205] = "ER_LOCK_WAIT_TIMEOUT";
map[1206] = "ER_LOCK_TABLE_FULL";
map[1207] = "ER_READ_ONLY_TRANSACTION";
map[1208] = "ER_DROP_DB_WITH_READ_LOCK";
map[1209] = "ER_CREATE_DB_WITH_READ_LOCK";
map[1210] = "ER_WRONG_ARGUMENTS";
map[1211] = "ER_NO_PERMISSION_TO_CREATE_USER";
map[1212] = "ER_UNION_TABLES_IN_DIFFERENT_DIR";
map[1213] = "ER_LOCK_DEADLOCK";
map[1214] = "ER_TABLE_CANT_HANDLE_FT";
map[1215] = "ER_CANNOT_ADD_FOREIGN";
map[1216] = "ER_NO_REFERENCED_ROW";
map[1217] = "ER_ROW_IS_REFERENCED";
map[1218] = "ER_CONNECT_TO_MASTER";
map[1219] = "ER_QUERY_ON_MASTER";
map[1220] = "ER_ERROR_WHEN_EXECUTING_COMMAND";
map[1221] = "ER_WRONG_USAGE";
map[1222] = "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT";
map[1223] = "ER_CANT_UPDATE_WITH_READLOCK";
map[1224] = "ER_MIXING_NOT_ALLOWED";
map[1225] = "ER_DUP_ARGUMENT";
map[1226] = "ER_USER_LIMIT_REACHED";
map[1227] = "ER_SPECIFIC_ACCESS_DENIED_ERROR";
map[1228] = "ER_LOCAL_VARIABLE";
map[1229] = "ER_GLOBAL_VARIABLE";
map[1230] = "ER_NO_DEFAULT";
map[1231] = "ER_WRONG_VALUE_FOR_VAR";
map[1232] = "ER_WRONG_TYPE_FOR_VAR";
map[1233] = "ER_VAR_CANT_BE_READ";
map[1234] = "ER_CANT_USE_OPTION_HERE";
map[1235] = "ER_NOT_SUPPORTED_YET";
map[1236] = "ER_MASTER_FATAL_ERROR_READING_BINLOG";
map[1237] = "ER_SLAVE_IGNORED_TABLE";
map[1238] = "ER_INCORRECT_GLOBAL_LOCAL_VAR";
map[1239] = "ER_WRONG_FK_DEF";
map[1240] = "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF";
map[1241] = "ER_OPERAND_COLUMNS";
map[1242] = "ER_SUBQUERY_NO_1_ROW";
map[1243] = "ER_UNKNOWN_STMT_HANDLER";
map[1244] = "ER_CORRUPT_HELP_DB";
map[1245] = "ER_CYCLIC_REFERENCE";
map[1246] = "ER_AUTO_CONVERT";
map[1247] = "ER_ILLEGAL_REFERENCE";
map[1248] = "ER_DERIVED_MUST_HAVE_ALIAS";
map[1249] = "ER_SELECT_REDUCED";
map[1250] = "ER_TABLENAME_NOT_ALLOWED_HERE";
map[1251] = "ER_NOT_SUPPORTED_AUTH_MODE";
map[1252] = "ER_SPATIAL_CANT_HAVE_NULL";
map[1253] = "ER_COLLATION_CHARSET_MISMATCH";
map[1254] = "ER_SLAVE_WAS_RUNNING";
map[1255] = "ER_SLAVE_WAS_NOT_RUNNING";
map[1256] = "ER_TOO_BIG_FOR_UNCOMPRESS";
map[1257] = "ER_ZLIB_Z_MEM_ERROR";
map[1258] = "ER_ZLIB_Z_BUF_ERROR";
map[1259] = "ER_ZLIB_Z_DATA_ERROR";
map[1260] = "ER_CUT_VALUE_GROUP_CONCAT";
map[1261] = "ER_WARN_TOO_FEW_RECORDS";
map[1262] = "ER_WARN_TOO_MANY_RECORDS";
map[1263] = "ER_WARN_NULL_TO_NOTNULL";
map[1264] = "ER_WARN_DATA_OUT_OF_RANGE";
map[1265] = "WARN_DATA_TRUNCATED";
map[1266] = "ER_WARN_USING_OTHER_HANDLER";
map[1267] = "ER_CANT_AGGREGATE_2COLLATIONS";
map[1268] = "ER_DROP_USER";
map[1269] = "ER_REVOKE_GRANTS";
map[1270] = "ER_CANT_AGGREGATE_3COLLATIONS";
map[1271] = "ER_CANT_AGGREGATE_NCOLLATIONS";
map[1272] = "ER_VARIABLE_IS_NOT_STRUCT";
map[1273] = "ER_UNKNOWN_COLLATION";
map[1274] = "ER_SLAVE_IGNORED_SSL_PARAMS";
map[1275] = "ER_SERVER_IS_IN_SECURE_AUTH_MODE";
map[1276] = "ER_WARN_FIELD_RESOLVED";
map[1277] = "ER_BAD_SLAVE_UNTIL_COND";
map[1278] = "ER_MISSING_SKIP_SLAVE";
map[1279] = "ER_UNTIL_COND_IGNORED";
map[1280] = "ER_WRONG_NAME_FOR_INDEX";
map[1281] = "ER_WRONG_NAME_FOR_CATALOG";
map[1282] = "ER_WARN_QC_RESIZE";
map[1283] = "ER_BAD_FT_COLUMN";
map[1284] = "ER_UNKNOWN_KEY_CACHE";
map[1285] = "ER_WARN_HOSTNAME_WONT_WORK";
map[1286] = "ER_UNKNOWN_STORAGE_ENGINE";
map[1287] = "ER_WARN_DEPRECATED_SYNTAX";
map[1288] = "ER_NON_UPDATABLE_TABLE";
map[1289] = "ER_FEATURE_DISABLED";
map[1290] = "ER_OPTION_PREVENTS_STATEMENT";
map[1291] = "ER_DUPLICATED_VALUE_IN_TYPE";
map[1292] = "ER_TRUNCATED_WRONG_VALUE";
map[1293] = "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS";
map[1294] = "ER_INVALID_ON_UPDATE";
map[1295] = "ER_UNSUPPORTED_PS";
map[1296] = "ER_GET_ERRMSG";
map[1297] = "ER_GET_TEMPORARY_ERRMSG";
map[1298] = "ER_UNKNOWN_TIME_ZONE";
map[1299] = "ER_WARN_INVALID_TIMESTAMP";
map[1300] = "ER_INVALID_CHARACTER_STRING";
map[1301] = "ER_WARN_ALLOWED_PACKET_OVERFLOWED";
map[1302] = "ER_CONFLICTING_DECLARATIONS";
map[1303] = "ER_SP_NO_RECURSIVE_CREATE";
map[1304] = "ER_SP_ALREADY_EXISTS";
map[1305] = "ER_SP_DOES_NOT_EXIST";
map[1306] = "ER_SP_DROP_FAILED";
map[1307] = "ER_SP_STORE_FAILED";
map[1308] = "ER_SP_LILABEL_MISMATCH";
map[1309] = "ER_SP_LABEL_REDEFINE";
map[1310] = "ER_SP_LABEL_MISMATCH";
map[1311] = "ER_SP_UNINIT_VAR";
map[1312] = "ER_SP_BADSELECT";
map[1313] = "ER_SP_BADRETURN";
map[1314] = "ER_SP_BADSTATEMENT";
map[1315] = "ER_UPDATE_LOG_DEPRECATED_IGNORED";
map[1316] = "ER_UPDATE_LOG_DEPRECATED_TRANSLATED";
map[1317] = "ER_QUERY_INTERRUPTED";
map[1318] = "ER_SP_WRONG_NO_OF_ARGS";
map[1319] = "ER_SP_COND_MISMATCH";
map[1320] = "ER_SP_NORETURN";
map[1321] = "ER_SP_NORETURNEND";
map[1322] = "ER_SP_BAD_CURSOR_QUERY";
map[1323] = "ER_SP_BAD_CURSOR_SELECT";
map[1324] = "ER_SP_CURSOR_MISMATCH";
map[1325] = "ER_SP_CURSOR_ALREADY_OPEN";
map[1326] = "ER_SP_CURSOR_NOT_OPEN";
map[1327] = "ER_SP_UNDECLARED_VAR";
map[1328] = "ER_SP_WRONG_NO_OF_FETCH_ARGS";
map[1329] = "ER_SP_FETCH_NO_DATA";
map[1330] = "ER_SP_DUP_PARAM";
map[1331] = "ER_SP_DUP_VAR";
map[1332] = "ER_SP_DUP_COND";
map[1333] = "ER_SP_DUP_CURS";
map[1334] = "ER_SP_CANT_ALTER";
map[1335] = "ER_SP_SUBSELECT_NYI";
map[1336] = "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG";
map[1337] = "ER_SP_VARCOND_AFTER_CURSHNDLR";
map[1338] = "ER_SP_CURSOR_AFTER_HANDLER";
map[1339] = "ER_SP_CASE_NOT_FOUND";
map[1340] = "ER_FPARSER_TOO_BIG_FILE";
map[1341] = "ER_FPARSER_BAD_HEADER";
map[1342] = "ER_FPARSER_EOF_IN_COMMENT";
map[1343] = "ER_FPARSER_ERROR_IN_PARAMETER";
map[1344] = "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER";
map[1345] = "ER_VIEW_NO_EXPLAIN";
map[1346] = "ER_FRM_UNKNOWN_TYPE";
map[1347] = "ER_WRONG_OBJECT";
map[1348] = "ER_NONUPDATEABLE_COLUMN";
map[1349] = "ER_VIEW_SELECT_DERIVED";
map[1350] = "ER_VIEW_SELECT_CLAUSE";
map[1351] = "ER_VIEW_SELECT_VARIABLE";
map[1352] = "ER_VIEW_SELECT_TMPTABLE";
map[1353] = "ER_VIEW_WRONG_LIST";
map[1354] = "ER_WARN_VIEW_MERGE";
map[1355] = "ER_WARN_VIEW_WITHOUT_KEY";
map[1356] = "ER_VIEW_INVALID";
map[1357] = "ER_SP_NO_DROP_SP";
map[1358] = "ER_SP_GOTO_IN_HNDLR";
map[1359] = "ER_TRG_ALREADY_EXISTS";
map[1360] = "ER_TRG_DOES_NOT_EXIST";
map[1361] = "ER_TRG_ON_VIEW_OR_TEMP_TABLE";
map[1362] = "ER_TRG_CANT_CHANGE_ROW";
map[1363] = "ER_TRG_NO_SUCH_ROW_IN_TRG";
map[1364] = "ER_NO_DEFAULT_FOR_FIELD";
map[1365] = "ER_DIVISION_BY_ZERO";
map[1366] = "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD";
map[1367] = "ER_ILLEGAL_VALUE_FOR_TYPE";
map[1368] = "ER_VIEW_NONUPD_CHECK";
map[1369] = "ER_VIEW_CHECK_FAILED";
map[1370] = "ER_PROCACCESS_DENIED_ERROR";
map[1371] = "ER_RELAY_LOG_FAIL";
map[1372] = "ER_PASSWD_LENGTH";
map[1373] = "ER_UNKNOWN_TARGET_BINLOG";
map[1374] = "ER_IO_ERR_LOG_INDEX_READ";
map[1375] = "ER_BINLOG_PURGE_PROHIBITED";
map[1376] = "ER_FSEEK_FAIL";
map[1377] = "ER_BINLOG_PURGE_FATAL_ERR";
map[1378] = "ER_LOG_IN_USE";
map[1379] = "ER_LOG_PURGE_UNKNOWN_ERR";
map[1380] = "ER_RELAY_LOG_INIT";
map[1381] = "ER_NO_BINARY_LOGGING";
map[1382] = "ER_RESERVED_SYNTAX";
map[1383] = "ER_WSAS_FAILED";
map[1384] = "ER_DIFF_GROUPS_PROC";
map[1385] = "ER_NO_GROUP_FOR_PROC";
map[1386] = "ER_ORDER_WITH_PROC";
map[1387] = "ER_LOGGING_PROHIBIT_CHANGING_OF";
map[1388] = "ER_NO_FILE_MAPPING";
map[1389] = "ER_WRONG_MAGIC";
map[1390] = "ER_PS_MANY_PARAM";
map[1391] = "ER_KEY_PART_0";
map[1392] = "ER_VIEW_CHECKSUM";
map[1393] = "ER_VIEW_MULTIUPDATE";
map[1394] = "ER_VIEW_NO_INSERT_FIELD_LIST";
map[1395] = "ER_VIEW_DELETE_MERGE_VIEW";
map[1396] = "ER_CANNOT_USER";
map[1397] = "ER_XAER_NOTA";
map[1398] = "ER_XAER_INVAL";
map[1399] = "ER_XAER_RMFAIL";
map[1400] = "ER_XAER_OUTSIDE";
map[1401] = "ER_XAER_RMERR";
map[1402] = "ER_XA_RBROLLBACK";
map[1403] = "ER_NONEXISTING_PROC_GRANT";
map[1404] = "ER_PROC_AUTO_GRANT_FAIL";
map[1405] = "ER_PROC_AUTO_REVOKE_FAIL";
map[1406] = "ER_DATA_TOO_LONG";
map[1407] = "ER_SP_BAD_SQLSTATE";
map[1408] = "ER_STARTUP";
map[1409] = "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR";
map[1410] = "ER_CANT_CREATE_USER_WITH_GRANT";
map[1411] = "ER_WRONG_VALUE_FOR_TYPE";
map[1412] = "ER_TABLE_DEF_CHANGED";
map[1413] = "ER_SP_DUP_HANDLER";
map[1414] = "ER_SP_NOT_VAR_ARG";
map[1415] = "ER_SP_NO_RETSET";
map[1416] = "ER_CANT_CREATE_GEOMETRY_OBJECT";
map[1417] = "ER_FAILED_ROUTINE_BREAK_BINLOG";
map[1418] = "ER_BINLOG_UNSAFE_ROUTINE";
map[1419] = "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER";
map[1420] = "ER_EXEC_STMT_WITH_OPEN_CURSOR";
map[1421] = "ER_STMT_HAS_NO_OPEN_CURSOR";
map[1422] = "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG";
map[1423] = "ER_NO_DEFAULT_FOR_VIEW_FIELD";
map[1424] = "ER_SP_NO_RECURSION";
map[1425] = "ER_TOO_BIG_SCALE";
map[1426] = "ER_TOO_BIG_PRECISION";
map[1427] = "ER_M_BIGGER_THAN_D";
map[1428] = "ER_WRONG_LOCK_OF_SYSTEM_TABLE";
map[1429] = "ER_CONNECT_TO_FOREIGN_DATA_SOURCE";
map[1430] = "ER_QUERY_ON_FOREIGN_DATA_SOURCE";
map[1431] = "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST";
map[1432] = "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE";
map[1433] = "ER_FOREIGN_DATA_STRING_INVALID";
map[1434] = "ER_CANT_CREATE_FEDERATED_TABLE";
map[1435] = "ER_TRG_IN_WRONG_SCHEMA";
map[1436] = "ER_STACK_OVERRUN_NEED_MORE";
map[1437] = "ER_TOO_LONG_BODY";
map[1438] = "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE";
map[1439] = "ER_TOO_BIG_DISPLAYWIDTH";
map[1440] = "ER_XAER_DUPID";
map[1441] = "ER_DATETIME_FUNCTION_OVERFLOW";
map[1442] = "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG";
map[1443] = "ER_VIEW_PREVENT_UPDATE";
map[1444] = "ER_PS_NO_RECURSION";
map[1445] = "ER_SP_CANT_SET_AUTOCOMMIT";
map[1446] = "ER_MALFORMED_DEFINER";
map[1447] = "ER_VIEW_FRM_NO_USER";
map[1448] = "ER_VIEW_OTHER_USER";
map[1449] = "ER_NO_SUCH_USER";
map[1450] = "ER_FORBID_SCHEMA_CHANGE";
map[1451] = "ER_ROW_IS_REFERENCED_2";
map[1452] = "ER_NO_REFERENCED_ROW_2";
map[1453] = "ER_SP_BAD_VAR_SHADOW";
map[1454] = "ER_TRG_NO_DEFINER";
map[1455] = "ER_OLD_FILE_FORMAT";
map[1456] = "ER_SP_RECURSION_LIMIT";
map[1457] = "ER_SP_PROC_TABLE_CORRUPT";
map[1458] = "ER_SP_WRONG_NAME";
map[1459] = "ER_TABLE_NEEDS_UPGRADE";
map[1460] = "ER_SP_NO_AGGREGATE";
map[1461] = "ER_MAX_PREPARED_STMT_COUNT_REACHED";
map[1462] = "ER_VIEW_RECURSIVE";
map[1463] = "ER_NON_GROUPING_FIELD_USED";
map[1464] = "ER_TABLE_CANT_HANDLE_SPKEYS";
map[1465] = "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA";
map[1466] = "ER_REMOVED_SPACES";
map[1467] = "ER_AUTOINC_READ_FAILED";
map[1468] = "ER_USERNAME";
map[1469] = "ER_HOSTNAME";
map[1470] = "ER_WRONG_STRING_LENGTH";
map[1471] = "ER_NON_INSERTABLE_TABLE";
exports.map = map;
lib/node-mysql/mysql/node-promise.js deleted 100644 → 0
// Promise library
// compatible with < 0.1.30
// It was changed for
// Original:
// nodejs v0.1.29
// Copyright 2009, 2010 Ryan Lienhart Dahl. All rights reserved.
// MIT License
var sys = require('sys');
var events = require('events');
exports.Promise = function () {
events.EventEmitter.call(this);
this._blocking = false;
this.hasFired = false;
this._values = undefined;
};
sys.inherits(exports.Promise, events.EventEmitter);
exports.Promise.prototype.timeout = function(timeout, createError) {
if (!timeout) {
return this._timeoutDuration;
}
this._timeoutDuration = timeout;
if (this.hasFired) return;
this._clearTimeout();
var self = this;
this._timer = setTimeout(function() {
self._timer = null;
if (self.hasFired) {
return;
}
self.emitError(createError ? createError() : new Error('timeout'));
}, timeout/100);
return this;
};
exports.Promise.prototype._clearTimeout = function() {
if (!this._timer) return;
clearTimeout(this._timer);
this._timer = null;
}
exports.Promise.prototype.emitSuccess = function() {
if (this.hasFired) return;
this.hasFired = 'success';
this._clearTimeout();
this._values = Array.prototype.slice.call(arguments);
this.emit.apply(this, ['success'].concat(this._values));
};
exports.Promise.prototype.emitError = function() {
if (this.hasFired) return;
this.hasFired = 'error';
this._clearTimeout();
this._values = Array.prototype.slice.call(arguments);
this.emit.apply(this, ['error'].concat(this._values));
if (this.listeners('error').length == 0) {
var self = this;
process.nextTick(function() {
if (self.listeners('error').length == 0) {
throw (self._values[0] instanceof Error)
? self._values[0]
: new Error('Unhandled emitError: '+JSON.stringify(self._values));
}
});
}
};
exports.Promise.prototype.addCallback = function (listener) {
if(typeof(listener)=='undefined') return this;;
if (this.hasFired === 'success') {
listener.apply(this, this._values);
}
return this.addListener("success", listener);
};
exports.Promise.prototype.addErrback = function (listener) {
if(typeof(listener)=='undefined') return this;
if (this.hasFired === 'error') {
listener.apply(this, this._values);
}
return this.addListener("error", listener);
};
/* Poor Man's coroutines */
var coroutineStack = [];
exports.Promise.prototype._destack = function () {
this._blocking = false;
while (coroutineStack.length > 0 &&
!coroutineStack[coroutineStack.length-1]._blocking)
{
coroutineStack.pop();
process.unloop("one");
}
};
lib/node-mysql/mysql/node-socket.js deleted 100644 → 0
//
// Append read() to tcp.Connection
//
var sys = require('sys');
var tcp = require("net");
var events = require("events");
var errors = require('./errors');
var utils = require('./utils');
var Promise = require('./node-promise').Promise;
var Socket = function(connect_callback, close_callback) {
this.conn = undefined;
this._timeout = 0;
this.buffer = '';
this.read_queue = [];
this.connect_callback = connect_callback;
this.close_callback = close_callback;
}
sys.inherits(Socket, events.EventEmitter);
exports.Socket = Socket;
Socket.prototype.timeout = function(timeout) {
this._timeout = timeout;
}
Socket.prototype.connect = function(port, host) {
if(this.conn) {
throw "Already open";
}
else {
this.conn = tcp.createConnection(port, host);
this.conn.addListener("data", utils.scope(this, function(data) {
this.buffer += data;
this.process_tcp_read_queue();
}));
this.conn.addListener("connect", utils.scope(this, function(){
this.conn.setEncoding("binary");
this.conn.setNoDelay(true);
this.conn.setTimeout(this._timeout);
this.connect_callback();
}));
this.conn.addListener("close", utils.scope(this, function(hasError) {
var task;
while(task=this.read_queue.shift()) {
task.promise.emitError(new errors.ClientError('connection was closed'));
}
this.conn = undefined;
this.close_callback(hasError);
}));
}
}
Socket.prototype.readyState = function() {
return this.conn.readyState;
}
Socket.prototype.close = function() {
if(this.conn) this.conn.end();
}
Socket.prototype.read = function(len) {
var promise = new Promise();
if(this._timeout) promise.timeout(this._timeout, function(){ return new errors.ClientError('connection timeout'); });
this.read_queue.push({len: len, promise: promise});
if(this.buffer) this.process_tcp_read_queue();
return promise;
}
Socket.prototype.process_tcp_read_queue = function() {
if(this.read_queue.length==0) return;
var task, data;
if(typeof(this.read_queue[0].len)=='undefined') {
task = this.read_queue.shift();
data = this.buffer;
this.buffer = '';
task.promise.emitSuccess(data);
}
else if(this.buffer.length>=this.read_queue[0].len) {
task = this.read_queue.shift();
data = this.buffer.substring(0, task.len);
this.buffer = this.buffer.slice(task.len);
task.promise.emitSuccess(data);
this.process_tcp_read_queue();
}
}
Socket.prototype.write = function(data) {
this.conn.write(data, 'binary');
}
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
*/
lib/node-mysql/mysql/pack.js deleted 100644 → 0
//
// pack/unpack style seralizer and deserializer.
//
exports.unpack = function(format, data) {
var result = [];
var instruction, quantifier, currentData, i, j, k;
while(format) {
instruction = format.substring(0,1);
format = format.slice(1);
quantifier = '1';
var q = format.match(/^(\*|\d+)/);
if(q!==null) {
quantifier = q[0];
format = format.slice(quantifier.length);
}
switch (instruction) {
case 'a': // NUL-padded string
case 'A': // SPACE-padded string
case 'Z': //
if (quantifier === '*') {
quantifier = data.indexOf( (instruction==='A'?" ":"\0"))+1;
if(!quantifier) quantifier = data.length;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier);
data = data.slice(quantifier);
if (instruction === 'a') {
currentResult = currentData.replace(/\0+$/, '');
}
else if (instruction === 'A') {
currentResult = currentData.replace(/ +$/, '');
}
else { // 'Z'
currentResult = currentData;
}
result.push(currentResult);
break;
case 'b': //
if (quantifier === '*') {
quantifier = data.length;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier);
data = data.slice(quantifier);
currentResult = '';
for (i=0;i<currentData.length;i++) {
j = parseInt(currentData.charCodeAt(i));
for(k=0; k<8; ++k) {
j <<= 1;
currentResult += (j>255) ? "1" : "0";
j &= 0xff;
}
}
result.push(currentResult);
break;
case 'c': // signed char
case 'C': // unsigned c
if (quantifier === '*') {
quantifier = data.length;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier);
data = data.slice(quantifier);
for (i=0;i<currentData.length;i++) {
currentResult = parseInt(currentData.charCodeAt(i));
if ((instruction === 'c') && (currentResult >= 128)) {
currentResult -= 256;
}
result.push(currentResult);
}
break;
case 'v': // unsigned short (always 16 bit, little endian byte order)
if (quantifier === '*') {
quantifier = (data.length) / 2;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier*2);
data = data.slice(quantifier*2);
for (i=0;i<currentData.length;i+=2) {
currentResult = parseInt(currentData.charCodeAt(i+1) << 8) +
parseInt(currentData.charCodeAt(i));
result.push(currentResult);
}
break;
case 'V': // unsigned long (always 32 bit, little endian byte order)
if (quantifier === '*') {
quantifier = (data.length) / 4;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier*4);
data = data.slice(quantifier*4);
for (i=0;i<currentData.length;i+=4) {
currentResult =
parseInt((currentData.charCodeAt(i+3) & 0xFF) << 24) +
parseInt((currentData.charCodeAt(i+2) & 0xFF) << 16) +
parseInt((currentData.charCodeAt(i+1) & 0xFF) << 8) +
parseInt((currentData.charCodeAt(i) & 0xFF));
result.push(currentResult);
}
break;
case 'e':
if (quantifier === '*') {
quantifier = (data.length) / 4;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier*4);
data = data.slice(quantifier*4);
for (i=0;i<currentData.length;i+=4) {
currentResult = decodeIEEE754(currentData.substring(i*4, i*4+4));
result.push(currentResult);
}
break;
case 'E':
if (quantifier === '*') {
quantifier = (data.length) / 8;
} else {
quantifier = parseInt(quantifier, 10);
}
currentData = data.substr(0, quantifier*8);
data = data.slice(quantifier*8);
for (i=0;i<currentData.length;i+=8) {
currentResult = decodeIEEE754(currentData.substring(i*8, i*8+8));
result.push(currentResult);
}
break;
default:
throw 'Warning: unpack() Type ' + instruction + ': unknown format code';
}
}
return result;
};
exports.pack = function(format) {
var result = "";
var instruction, quantifier, currentData;
var argumentPointer = 1;
var args = arguments;
if(args[1].constructor.toString().indexOf(" Array(") >= 0) {
args = args[1];
argumentPointer = 0;
}
while(format) {
instruction = format.substring(0,1);
format = format.slice(1);
quantifier = '1';
var q = format.match(/^(\*|\d+)/);
if(q!==null) {
quantifier = q[0];
format = format.slice(quantifier.length);
}
switch (instruction) {
case 'a': //NUL-padded string
case 'A': //SPACE-padded string
case 'Z':
if (typeof args[argumentPointer] === 'undefined') {
throw new Error('Warning: pack() Type ' + instruction +
': not enough arguments');
} else {
argument = String(args[argumentPointer]);
}
if (quantifier === '*') {
quantifier = argument.length + ((instruction === 'a') ? 1 : 0);
}
for (i = 0; i < quantifier; i ++) {
if (typeof(argument[i]) === 'undefined') {
if (instruction === 'a') {
result += String.fromCharCode(0);
} else {
result += ' ';
}
} else {
result += argument[i];
}
}
argumentPointer++;
break;
case 'c': //signed char
case 'C': //unsigned char
//c and C is the same in pack
if (quantifier === '*') {
quantifier = args.length - argumentPointer;
}
if (quantifier > (args.length - argumentPointer)) {
throw new Error('Warning: pack() Type ' + instruction +
': too few arguments');
}
for (i = 0; i < quantifier; i++) {
result += String.fromCharCode(args[argumentPointer]);
argumentPointer++;
}
break;
case 'v': //s and S is the same in pack
//but can machine byte order be retrieved in javascript?
//this is default byte order anywayz...
if (quantifier === '*') {
quantifier = args.length - argumentPointer;
}
if (quantifier > (args.length - argumentPointer)) {
throw new Error('Warning: pack() Type ' + instruction +
': too few arguments');
}
for (i = 0; i < quantifier; i++) {
result += String.fromCharCode(args[argumentPointer] &
0xFF);
result += String.fromCharCode(args[argumentPointer] >> 8 & 0xFF);
argumentPointer++;
}
break;
case 'V': // unsigned long (always 32 bit, little endian byte order)
if (quantifier === '*') {
quantifier = args.length - argumentPointer;
}
if (quantifier > (args.length - argumentPointer)) {
throw new Error('Warning: pack() Type ' + instruction +
': too few arguments');
}
for (i = 0; i < quantifier; i++) {
result += String.fromCharCode(args[argumentPointer] & 0xFF);
result += String.fromCharCode(args[argumentPointer] >> 8 & 0xFF);
result += String.fromCharCode(args[argumentPointer] >> 16 & 0xFF);
result += String.fromCharCode(args[argumentPointer] >> 24 & 0xFF);
argumentPointer++;
}
break;
case 'e': // IEEE754 32bit
if (quantifier === '*') {
quantifier = args.length - argumentPointer;
}
if (quantifier > (args.length - argumentPointer)) {
throw new Error('Warning: pack() Type ' + instruction +
': too few arguments');
}
for (i = 0; i < quantifier; i++) {
result += encodeIEEE754(args[argumentPointer], 'float');
argumentPointer++;
}
break;
case 'E': // IEEE754 64bit
if (quantifier === '*') {
quantifier = args.length - argumentPointer;
}
if (quantifier > (args.length - argumentPointer)) {
throw new Error('Warning: pack() Type ' + instruction +
': too few arguments');
}
for (i = 0; i < quantifier; i++) {
result += encodeIEEE754(args[argumentPointer], 'double');
argumentPointer++;
}
break;
default:
throw 'Warning: pack() Type ' + instruction + ': unknown format code';
}
}
return result;
};
var encodeIEEE754 = function(val, type) {
var config = {
'double': {
bias: 1023,
bytes: 8,
exp: 11,
POSITIVE_INFINITY: Number.POSITIVE_INFINITY,
NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
qNAN: String.fromCharCode(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff),
pINF: String.fromCharCode(0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
nINF: String.fromCharCode(0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00),
zero: String.fromCharCode(0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
},
'float': {
bias: 127,
bytes: 4,
exp: 8,
POSITIVE_INFINITY: (2 - Math.pow(2, -23)) * Math.pow(2, 127),
NEGATIVE_INFINITY: -(2 - Math.pow(2, -23)) * Math.pow(2, 127),
qNAN: String.fromCharCode(0xff, 0xff, 0xff, 0xff),
pINF: String.fromCharCode(0x7f, 0x80, 0x00, 0x00),
nINF: String.fromCharCode(0xff, 0x80, 0x00, 0x00),
zero: String.fromCharCode(0x00, 0x00, 0x00, 0x00)
}
}[type || 'double'];
if ( isNaN(val) ) return config.qNAN;
if ( val >= config.POSITIVE_INFINITY ) return config.pINF;
if ( val <= config.NEGATIVE_INFINITY ) return config.nINF;
if ( Math.abs(val) == 0 ) return config.zero;
var zeropadding = function(val,len,prepare) {
var padding = "0000000000".substring(0,len-val.length);
return prepare ? padding+val : val+padding;
}
var bval = Math.abs(val).toString(2);
var exp = bval.indexOf(".") - 1 + config.bias;
var bfrac = bval.replace(".", "");
exp -= bfrac.indexOf("1");
bfrac = bfrac.substring(bfrac.indexOf("1")+1);
var bits = (val<0?"1":"0")+zeropadding(exp.toString(2), config.exp, true)+bfrac;
result = [];
for (var i = 0; i < config.bytes; i++) {
result.push(String.fromCharCode(parseInt(zeropadding(bits.substring(i*8,i*8+8),8,false),2)));
}
return result.reverse().join("");
};
var decodeIEEE754 = function(data) {
var bits = data.split('').map(function(s){return s.charCodeAt(0);}).reverse();
var n = bits.length;
var config = {
4: {
bias: 127,
sgnd: 23,
pbias: Math.pow(2, 126),
psgnd: Math.pow(2, 23)
},
8: {
bias: 1023,
sgnd: 52,
pbias: Math.pow(2, 1022),
psgnd: Math.pow(2, 52)
}
}[n];
var e, m;
if ( n == 4 ) {
e = ((bits[0] & 0x7f) << 1) + (bits[1] >> 7);
m = bits[1] & 0x7f;
}
else if ( n == 8 ) {
e = ((bits[0] & 0x7f) << 4) + (bits[1] >> 4);
m = bits[1] & 0x0f;
}
else {
throw "Range error";
}
s = bits[0] & 0x80;
for (var i = 2; i < n; i++) {
m = m * 0x100 + bits[i];
}
// e = 0xff, 0x7ff - +INF, -INF or NAN
if ( e == config.bias * 2 + 1 ) {
// NAN
if ( m ) {
return 0 / 0;
}
// +INF, -INF
return (s ? -1 : +1) / 0;
}
var result = e
? (m / config.psgnd + 1) * Math.pow(2, e - config.bias)
: m / config.psgnd / config.pbias;
return s ? -result : result;
};
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
*/
// pack/unpack Original
// MIT license http://phpjs.org/functions/pack:880
// http://kevin.vanzonneveld.net
// + original by: Tim de Koning (http://www.kingsquare.nl)
// + parts by: Jonas Raoni Soares Silva
// + http://www.jsfromhell.com // % note 1: Float encoding by: Jonas Raoni Soares Silva
// encode/decodeFloat Original
// http://snippets.dzone.com/posts/show/685
\ No newline at end of file
lib/node-mysql/mysql/packet.js deleted 100644 → 0
var sys = require('sys');
var pack = require('./pack');
var constants = require('./constants');
var utils = require('./utils');
var types = require('./types');
var Charset = require('./charset').Charset;
var Promise = require('./node-promise').Promise;
// convert Numeric to LengthCodedBinary
var lcb = function(num) {
if(num==undefined) return "\xfb";
if(num<251) return pack.pack("C", num);
if(num<65536) return pack.pack("Cv", 252, num);
if(num<16777216) return pack.pack("CvC", 253, num&0xffff, num>>16);
return pack.pack("CVV", 254, num&0xffffffff, num>>32);
}
/* convert LengthCodedBinary to Integer
# === Argument
# lcb :: [String] LengthCodedBinary. This value will be broken.
# === Return
# Integer or nil */
var lcb2int = function(lcbs) {
if(!lcbs[0]) return undefined;
var ret;
var lcb = lcbs[0];
var v = lcb.substring(0,1);
lcb = lcb.slice(1);
switch(v) {
case "\xfb":
v = undefined;
break;
case "\xfc":
v = pack.unpack("v", lcb.substring(0,2))[0];
lcb = lcb.slice(2);
break;
case "\xfd":
v = pack.unpack("Cv", lcb.substring(0,3));
lcb = lcb.slice(3);
v = (v[1]<<8)+v[0];
break;
case "\xfe":
v = pack.unpack("VV", lcb.substring(0,8));
lcb = lcb.slice(8);
v = (v[1]<<32)+v[0];
break;
default:
v = v.charCodeAt(0);
break;
}
lcbs[0] = lcb;
return(v);
}
var lcs = function(str) {
return lcb(str.length)+str;
}
var lcs2str = function(lcs) {
var len = lcb2int(lcs);
if(typeof(len)=="undefined") return undefined;
var data = lcs[0].substring(0, len);
lcs[0] = lcs[0].slice(len);
return data;
}
exports.lcs2str = lcs2str;
var net2value = function(adata, field, charset) {
var unsigned = !!(field.flags & constants.field.UNSIGNED_FLAG);
var binary = !!(field.flags & constants.field.BINARY_FLAG);
var type = field.type;
switch(type.id) {
case constants.field.TYPE_BLOB:
case constants.field.TYPE_STRING:
case constants.field.TYPE_VAR_STRING:
case constants.field.TYPE_NEWDECIMAL:
if(binary) {
return lcs2str(adata);
}
else {
return charset.convertFromBytes(lcs2str(adata));
}
case constants.field.TYPE_TINY:
var data = adata[0].substring(0, 1);
adata[0] = adata[0].substring(1);
var v = pack.unpack("C", data)[0]
return unsigned ? v : v < (256)/2 ? v : v-(256);
case constants.field.TYPE_SHORT:
var data = adata[0].substring(0, 2);
adata[0] = adata[0].substring(2);
var v = pack.unpack("v", data)[0]
return unsigned ? v : v < (65536)/2 ? v : v-(65536);
case constants.field.TYPE_INT24:
case constants.field.TYPE_LONG:
var data = adata[0].substring(0, 4);
adata[0] = adata[0].substring(4);
var v = pack.unpack("V", data)[0]
return unsigned ? v : v < (4294967296)/2 ? v : v-(4294967296);
case constants.field.TYPE_LONGLONG:
var data = adata[0].substring(0, 8);
adata[0] = adata[0].substring(8);
var n = pack.unpack("VV", data)
var v = (n[1] << 32) | n[0];
return unsigned ? v : v < (18446744073709551616)/2 ? v : v-(18446744073709551616);
case constants.field.TYPE_FLOAT:
var data = adata[0].substring(0, 4);
adata[0] = adata[0].substring(4);
return pack.unpack("e", data)[0]
case constants.field.TYPE_DOUBLE:
var data = adata[0].substring(0, 8);
adata[0] = adata[0].substring(8);
return pack.unpack("E", data)[0]
case constants.field.TYPE_DATE:
case constants.field.TYPE_DATETIME:
case constants.field.TYPE_TIMESTAMP:
var len = adata[0].charCodeAt(0);
var data = adata[0].substring(1, len+1+1);
adata[0] = adata[0].substring(len+1+1);
var ret = pack.unpack("vCCCCCV", data);
return new types.Time(ret[0], ret[1], ret[2], ret[3], ret[4], ret[5], ret[6]);
case constants.field.TYPE_TIME:
var len = adata[0].charCodeAt(0);
var data = adata[0].substring(1, len+1+1);
adata[0] = adata[0].substring(len+1+1);
var ret = pack.unpack("CVCCCV", data);
return new types.Time(0, 0, 0, ret[1]*24+ret[2], ret[3], ret[4], ret[0]!=0, ret[5]);
case constants.field.TYPE_YEAR:
var data = adata[0].substring(0, 2);
adata[0] = adata[0].substring(2);
return pack.unpack("v", data)[0];
case constants.field.TYPE_BIT:
return lcs2str(adata);
default:
throw "not implemented: type="+type;
}
}
var value2net = function(v, charset) {
var val = '', type=0;
switch(typeof(v)) {
case 'undefined':
type = constants.field.TYPE_NULL;
val = "";
break;
case 'number':
if(parseInt(v)==v) { // is integer
if(v >= 0) {
if(v < 256) {
type = constants.field.TYPE_TINY | 0x8000;
val = pack.pack("C", v);
}
else if(v < 256*256) {
type = constants.field.TYPE_SHORT | 0x8000;
val = pack.pack("v", v);
}
else if(v < 256*256*256*256) {
type = constants.field.TYPE_LONG | 0x8000;
val = pack.pack("V", v);
}
else if(v < 256*256*256*256*256*256*256*256) {
type = constants.field.TYPE_LONGLONG | 0x8000
val = pack.pack("VV", v&0xffffffff, v>>32);
}
else {
throw "value too large: "+v;
}
}
else {
if(-1*v <= 256/2) {
type = constants.field.TYPE_TINY;
val = pack.pack("C", v);
}
else if(-1*v <= (256*256)/2) {
type = constants.field.TYPE_SHORT;
val = pack.pack("v", v);
}
else if(-1*v <= (256*256*256*256)/2) {
type = constants.field.TYPE_LONG;
val = pack.pack("V", v);
}
else if(-1*v <= (256*256*256*256*256*256*256*256)/2) {
type = constants.field.TYPE_LONGLONG;
val = pack.pack("VV", v&0xffffffff, v>>32);
}
else {
throw "value too large: "+v;
}
}
}
else { // is double
type = constants.field.TYPE_DOUBLE;
val = pack.pack("E", v);
}
break;
case 'string':
type = constants.field.TYPE_STRING;
val = lcs(charset.convertToBytes(v));
break;
case 'object':
if(v.constructor.toString().indexOf(" Date(")) {
type = constants.field.TYPE_DATETIME;
val = pack.pack("CvCCCCC", 7, v.year, v.month, v.day, v.hour, v.minute, v.second);
}
else if(v.year || v.month || v.day || v.hour || v.minute || v.second) {
type = constants.field.TYPE_DATETIME;
val = pack.pack("CvCCCCC", 7, v.year, v.month, v.day, v.hour, v.minute, v.second);
}
else {
throw "class: "+v+" is not supported";
}
break;
default:
throw "class: "+v+" is not supported";
}
return [type, val];
}
exports.InitialPacket = function(data) {
res = pack.unpack("Ca*Va8CvCva13a13", data);
this.protocol_version = res[0]; // C
this.server_version = res[1]; // a*
this.thread_id = res[2]; // V
this.scramble_buff = res[3]+res[9]; // a8 + a13
this.server_capabilities = res[5]; // v
this.server_charset = res[6]; // C
this.server_status = res[7]; // v
};
exports.AuthenticationPacket = function(client_flags, max_packet_size, charset_number, username, scrambled_password, databasename) {
return(pack.pack("VVca23a*A*a*",
client_flags,
max_packet_size,
charset_number,
"", // always 0x00 * 23
username,
lcs(scrambled_password),
databasename || ''
));
};
// Field packet
var FieldPacket = function(db, table, org_table, name, org_name, charsetnr, length, type, flags, decimals, defaultVal) {
this.db = db;
this.table = table;
this.org_table = org_table;
this.name = name;
this.org_name = org_name;
this.charsetnr = charsetnr;
this.length = length;
this.type = types.Types[type];
this.flags = flags;
this.decimals = decimals;
this.defaultVal = defaultVal;
}
exports.FieldPacket = FieldPacket;
FieldPacket.parse = function(data) {
var adata = [data];
var first = lcs2str(adata);
var db = lcs2str(adata);
var table = lcs2str(adata);
var org_table = lcs2str(adata);
var name = lcs2str(adata);
var org_name = lcs2str(adata);
var more = pack.unpack("CvVCvCva*", adata[0]);
if(more[6]!=0) return undefined;
// raise ProtocolError, "invalid packet: f1="+etc[0]+"" unless etc[0] == 0
var defaultVal = lcs2str([more[7]]);
return new FieldPacket(db, table, org_table, name, org_name, more[1], more[2], more[3], more[4], more[5], defaultVal);
}
var ResultPacket = function(field_count, affected_rows, insert_id, server_status, warning_count, message) {
this.field_count = field_count;
this.affected_rows = affected_rows;
this.insert_id = insert_id;
this.server_status = server_status;
this.warning_count = warning_count;
this.message = message;
}
exports.ResultPacket = ResultPacket;
ResultPacket.parse = function(data) {
var adata = [data];
var field_count = lcb2int(adata);
if(field_count == 0) {
var affected_rows = lcb2int(adata);
var insert_id = lcb2int(adata);
var ret = pack.unpack("vva*", adata[0]);
var server_status = ret[0];
var warning_count = ret[1];
var message = lcs2str([ret[2]]);
return(new ResultPacket(field_count, affected_rows, insert_id, server_status, warning_count, message));
}
else if(typeof(field_count)=='undefined') {
return(new ResultPacket(undefined, undefined, undefined, undefined, undefined, adata[0]));
}
return(new ResultPacket(field_count))
}
var PrepareResultPacket = function(statement_id, field_count, param_count, warning_count) {
this.statement_id = statement_id;
this.field_count = field_count;
this.param_count = param_count;
this.warning_count = warning_count;
}
exports.PrepareResultPacket = PrepareResultPacket;
PrepareResultPacket.parse = function(data) {
var res = pack.unpack("cVvvCv", data);
if(res[0]!=0 || res[4]!=0) throw("invalid packet");
return new PrepareResultPacket(res[1], res[2], res[3], res[5]);
}
var ExecutePacket = {}
exports.ExecutePacket = ExecutePacket;
ExecutePacket.serialize = function(statement_id, cursor_type, values, charset) {
var nbm = null_bitmap(values);
var netvalues = "";
var types = values.map(function(v) {
var ret = value2net(v, charset);
if(typeof(v)!='undefined') {
netvalues = netvalues.concat(ret[1]);
}
return ret[0];
});
return pack.pack("CVCVZ*CZ*Z*", constants.com.STMT_EXECUTE, statement_id, cursor_type, 1, nbm, 1, pack.pack("v*", types), netvalues);
}
// make null bitmap
// If values is [1, nil, 2, 3, nil] then returns "\x12"(0b10010).
var null_bitmap = function(values) {
var val=0, len=0, bitmap=[];
values.map(function(v) {
val += (typeof(v)=="undefined" ? 1<<len : 0);
len += 1;
if(len==8) {
bitmap.push(val);
len = val = 0;
}
return val;
});
if(len>0) {
bitmap.push(val);
}
return pack.pack("C*", bitmap);
}
// StatementRecord packet
var StatementRecordPacket = function(){
}
exports.StatementRecordPacket = StatementRecordPacket;
StatementRecordPacket.parse = function(data, fields, charset) {
var null_bit_map_len = (fields.length+7+2)/8;
var null_bit_map = pack.unpack("b*", data.substring(1, null_bit_map_len+1+1))[0];
var i = -1, v;
var adata = [data.substring(1+null_bit_map_len)];
return fields.map(function(field) {
i += 1;
if(null_bit_map.substring(i+2,i+3) == '1') {
return undefined;
}
else {
return net2value(adata, field, charset);
}
});
}
lib/node-mysql/mysql/protocol.js deleted 100644 → 0
// Protocol:
// MySQL Protocol
var sys = require('sys');
var fs = require("fs");
var events = require('events');
var pack = require('./pack');
var errors = require('./errors');
var constants = require('./constants');
var packet = require('./packet');
var auth = require('./auth');
var utils = require('./utils');
var Charset = require('./charset').Charset;
var Promise = require('./node-promise').Promise;
var Connection = require('./connection').Connection;
var Protocol = function(host, port) {
events.EventEmitter.call(this);
this.state = undefined;
this.gc_stmt_queue = [];
this.ready_state_queue = [];
this.charset = undefined;
this.authinfo = undefined;
this.server_info = undefined;
this.server_version = undefined;
this.thread_id = undefined;
this.message = undefined;
this.affected_rows = undefined;
this.insert_id = undefined;
this.server_status = undefined;
this.warning_count = undefined;
this.request_close = false;
this.set_state('INIT');
this.conn = new Connection(port || 3306, host || 'localhost');
this.conn.addListener('connect', utils.scope(this, function() {
this.emit('connect');
}));
this.conn.addListener('close', utils.scope(this, function() {
this.gc_stmt_queue = [];
this.set_state('INIT');
this.emit('close');
}));
this.conn.connect();
}
sys.inherits(Protocol, events.EventEmitter);
exports.Protocol = Protocol;
// close TCP session
Protocol.prototype.close = function() {
if(this.state=='INIT' && this.ready_state_queue.length==0) {
this.conn.close();
}
else {
this.wait_ready_state(undefined, utils.scope(this, function(error) {
this.conn.close();
}));
}
}
Protocol.prototype.timeout = function(msec) {
if(this.conn) this.conn.timeout(msec);
}
Protocol.prototype.gc_stmt = function(stmt_id) {
this.gc_stmt_queue.push(stmt_id);
}
// authenticate process
Protocol.prototype.authenticate = function(user, passwd, db, flag, charset_str) {
var promise = new Promise();
if(!this.check_state('INIT', promise)) return promise;
this.authinfo = [user, passwd, db, flag, charset_str];
this.conn.reset();
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
var init_packet = new packet.InitialPacket(buff);
if(init_packet.protocol_version!=10) {
promise.emitError(new errors.ClientError("Don't support protocol version "+init_packet.protocol_version));
this.flush_ready_state(new errors.ClientError("Don't support protocol version "+init_packet.protocol_version));
return;
}
this.server_info = init_packet.server_version;
var i = init_packet.server_version.split(".");
this.server_version = parseInt(i[0])*100+parseInt(i[1]);
this.thread_id = init_packet.thread_id;
var client_flags = constants.client.LONG_PASSWORD
| constants.client.LONG_FLAG
| constants.client.TRANSACTIONS
| constants.client.PROTOCOL_41
| constants.client.SECURE_CONNECTION;
if(db) client_flags |= constants.client.CONNECT_WITH_DB;
client_flags |= flag;
if(charset_str) {
this.charset = Charset.by_name(charset_str);
}
else {
this.charset = Charset.by_number(init_packet.server_charset);
}
var netpw = auth.encrypt_password(passwd, init_packet.scramble_buff);
try {
this.conn.write(packet.AuthenticationPacket(client_flags, 1024*1024*1024, this.charset.number, user, netpw, db))
.addErrback(utils.scope(this, function(error) {
this.emit("authorize error");
promise.emitError(error);
}));
this.conn.read()
.addCallback(utils.scope(this, function(buff){
this.query_command("SET NAMES '"+this.charset.name+"'", true)
.addErrback(utils.scope(this, function(error) {
this.emit("authorize error");
promise.emitError(error);
}));
this.set_state('READY');
this.emit("authorized");
promise.emitSuccess();
}))
.addErrback(utils.scope(this, function(error) {
this.emit("authorize error");
promise.emitError(error);
}));
}
catch(e) {
promise.emitError(new errors.ClientError(e.message));
}
}))
.addErrback(utils.scope(this, function(error) {
this.emit("authorize error", new errors.ClientError('authorize error'));
promise.emitError(error);
}));
return promise;
}
// send query command
Protocol.prototype.query_command = function(query, immediately) {
var promise = new Promise();
var err = utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
});
this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
if(error) {
this.set_state('READY');
return(promise.emitError(error));
}
this.conn.reset();
this.conn.write(pack.pack("CZ*", constants.com.QUERY, this.charset.convertToBytes(query)))
.addCallback(utils.scope(this, function(buff) {
this.get_result()
.addCallback(function(nfields) {
promise.emitSuccess(nfields);
})
.addErrback(err);
}))
.addErrback(err);
}), immediately);
return promise;
}
// read result fields count
Protocol.prototype.get_result = function() {
var promise = new Promise();
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
var res_packet = packet.ResultPacket.parse(buff);
this.affected_rows = res_packet.affected_rows;
this.insert_id = res_packet.insert_id;
this.server_status = res_packet.server_status;
this.warning_count = res_packet.warning_count;
this.message = res_packet.message;
if(res_packet.field_count>0) { // result data exists
this.set_state('FIELD');
promise.emitSuccess(res_packet.field_count);
}
else if(typeof(res_packet.field_count)=='undefined') { // LOAD DATA LOCAL INFILE
var filename = res_packet.message
fs.readFile(filename, 'UTF-8', utils.scope(this, function(err, data) {
if(err) {
promise.emitError(new errors.ClientError("Can't read '"+filename+"'"));
this.set_state('READY');
return;
}
var error_handler = utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
});
this.conn.write(data).addErrback(error_handler);
this.conn.write().addErrback(error_handler); // EOF mark
this.conn.read()
.addCallback(utils.scope(this, function() {
this.set_state('READY');
promise.emitSuccess(undefined);
}))
.addErrback(error_handler);
}));
}
else { // field_count == 0
this.set_state('READY');
promise.emitSuccess(undefined);
}
}))
.addErrback(function(error) {
promise.emitError(error);
});
return promise;
}
// Set option command
Protocol.prototype.set_option_command = function(opt) {
return this.simple_command(pack.pack("Cv", constants.com.SET_OPTION, opt));
}
// send simple command
Protocol.prototype.simple_command = function(packet) {
var promise = new Promise();
var err = utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
});
this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
if(error) {
this.set_state('READY');
return(promise.emitError(error));
}
this.conn.reset();
this.conn.write(packet)
.addCallback(utils.scope(this, function() {
this.conn.read()
.addCallback(utils.scope(this, function() {
this.set_state('READY');
promise.emitSuccess();
}))
.addErrback(err);
}))
.addErrback(err);
}));
return promise;
}
// get field info
Protocol.prototype.retr_fields = function(nfields) {
var promise = new Promise();
if(!this.check_state('FIELD', promise)) return promise;
var fields = [];
for(var i=0; i<nfields; ++i) {
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
fields.push(packet.FieldPacket.parse(buff));
if(fields.length>=nfields) {
this.read_eof_packet()
.addCallback(utils.scope(this, function(buff) {
this.set_state('RESULT');
promise.emitSuccess(fields);
}))
.addErrback(utils.scope(function(error) {
this.set_state('READY');
promise.emitError(error);
}));
}
}))
.addErrback(utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
}));
}
return promise;
}
//
Protocol.prototype.read_eof_packet = function(nfields) {
var promise = new Promise();
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
if(is_eof_packet(buff)) {
promise.emitSuccess();
}
else {
promise.emitError(new errors.ProtocolError("packet is not EOF"));
}
}))
.addErrback(utils.scope(function(error) {
promise.emitError(error);
}));
return promise;
};
var is_eof_packet = function(data) {
return data.substring(0,1)=="\xfe" && data.length==5;
}
Protocol.prototype.retr_all_records = function(fields, each_callback, end_callback) {
var promise = new Promise();
if(!this.check_state('RESULT', promise)) return promise;
var get_line = utils.scope(this, function() {
this.conn.read()
.addCallback(utils.scope(this, function(data) {
if(is_eof_packet(data)) {
this.server_status = data.charCodeAt(3);
this.set_state('READY');
promise.emitSuccess(end_callback());
}
else {
var rec = [], adata = [data];
for(var i=0; i<fields.length; ++i) {
var val = packet.lcs2str(adata);
rec.push(fields[i].type.convert(val, this.charset, fields[i]));
}
each_callback(rec);
get_line();
}
}))
.addErrback(utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
}));
});
get_line();
return promise;
}
Protocol.prototype.stmt_prepare_command = function(stmt) {
var promise = new Promise();
this.wait_ready_state('PROCESS', utils.scope(this, function(error) {
if(error) {
this.set_state('READY');
return(promise.emitError(error));
}
this.conn.reset();
this.conn.write(pack.pack("Ca*", constants.com.STMT_PREPARE, this.charset.convertToBytes(stmt)))
.addErrback(function(error) {
promise.emitError(error);
});
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
var res_packet = packet.PrepareResultPacket.parse(buff);
var func = utils.scope(this, function() {
if(res_packet.field_count > 0) {
this.conn.read(res_packet.field_count) // skip parameter packet
.addCallback(utils.scope(this, function(packets) {
field_packets = [];
for(var i=0; i<res_packet.field_count; ++i) {
field_packets.push(packet.FieldPacket.parse(packets[i]));
}
this.read_eof_packet()
.addCallback(utils.scope(this, function() {
promise.emitSuccess(res_packet.statement_id, res_packet.param_count, field_packets);
}))
.addErrback(function(error) {
promise.emitError(error);
});
}))
.addErrback(function(error) {
promise.emitError(error);
});
}
else {
promise.emitSuccess(res_packet.statement_id, res_packet.param_count, []);
}
});
if(res_packet.param_count > 0) {
this.conn.read(res_packet.param_count) // skip parameter packet
.addCallback(utils.scope(this, function(){
this.read_eof_packet()
.addCallback(utils.scope(this, function() {
func();
}));
}));
}
else {
func();
}
}))
.addErrback(function(error) {
promise.emitError(error);
});
}));
return promise;
}
Protocol.prototype.stmt_close_command = function(promise, stmt_id) {
if(typeof(stmt_id)!='undefined') {
this.conn.reset();
this.conn.write(pack.pack("CV", constants.com.STMT_CLOSE, stmt_id));
}
}
Protocol.prototype.stmt_execute_command = function(stmt_id, values) {
var promise = new Promise();
var err = utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
});
this.check_state('READY');
this.conn.reset();
this.conn.write(packet.ExecutePacket.serialize(stmt_id, constants.stmt.CURSOR_TYPE_NO_CURSOR, values, this.charset))
.addErrback(function(error){ promise.emitError(error); });
this.get_result()
.addCallback(function(nfields) {
promise.emitSuccess(nfields);
})
.addErrback(err);
return promise;
}
Protocol.prototype.stmt_retr_all_records = function(fields, charset) {
var promise = new Promise();
this.check_state('RESULT');
var all_recs = [];
var err = utils.scope(this, function(error) {
this.set_state('READY');
promise.emitError(error);
});
var func = utils.scope(this, function() {
this.conn.read()
.addCallback(utils.scope(this, function(buff) {
if(is_eof_packet(buff)) {
this.set_state('READY');
promise.emitSuccess(all_recs);
}
else {
all_recs.push(packet.StatementRecordPacket.parse(buff, fields, this.charset));
func();
}
}))
.addErrback(err);
});
func();
return promise;
}
// set protocol state
Protocol.prototype.set_state = function(state) {
if(this.state == state) return;
this.state = state;
if(state=='READY') {
while(st = this.gc_stmt_queue.shift()) {
this.stmt_close_command(st);
}
if(this.ready_state_queue.length>0) {
var task = this.ready_state_queue.shift();
if(task[0]) this.set_state(task[0]);
process.nextTick(task[1]);
}
}
}
// check protocol state
Protocol.prototype.check_state = function(st, promise) {
if(this.state==st) {
return true;
}
else {
if(promise) promise.emitError(new errors.ProtocolError("Unmatch protocol state "+st+"(expect) != "+this.state));
return false;
}
}
// wait changing to state
Protocol.prototype.wait_ready_state = function(state, callback, immediately) {
if(immediately) {
this.ready_state_queue.unshift([state, callback]);
}
else {
this.ready_state_queue.push([state, callback]);
}
if(this.state=='READY') {
var task = this.ready_state_queue.shift();
if(task[0]) this.set_state(task[0]);
process.nextTick(task[1]);
}
}
Protocol.prototype.flush_ready_state = function(error) {
var task;
while(task = this.ready_state_queue.shift()) {
if(task[0]) this.set_state(task[0]);
task[1](error);
}
}
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/result.js deleted 100644 → 0
// Result:
// Result set
var sys = require('sys');
var utils = require('./utils');
// Result set
var ResultBase = function(fields) {
this.fields = fields;
this.records = [];
this.fieldname_with_table = false;
}
exports.ResultBase = ResultBase;
var Result = function(fields, protocol) {
ResultBase.call(this, fields);
this.protocol = protocol;
}
sys.inherits(Result, ResultBase);
exports.Result = Result;
Result.prototype.fetch_all = function() {
var promise = this.protocol.retr_all_records(this.fields,
utils.scope(this, function(rec) { // each
this.records.push(rec);
}),
utils.scope(this, function() { // result
return this;
}));
return promise;
}
Result.prototype.toHash = function(row) {
var result, name, field;
result = {};
for(var i = 0; i<this.fields.length; ++i) {
field = this.fields[i];
name = ((this.fieldname_with_table && field.table) ? (field.table+".") : "") + field.name;
result[name] = row[i];
}
return result;
}
var StatementResult = function(fields, protocol) {
ResultBase.call(this, fields);
this.protocol = protocol;
}
sys.inherits(StatementResult, ResultBase);
exports.StatementResult = Result;
/*
node-mysql
A node.js interface for MySQL
Author: masuidrive <masui@masuidrive.jp>
License: MIT License
Copyright (c) Yuichiro MASUI
# Original:
# http://github.com/tmtm/ruby-mysql
# Copyright (C) 2009-2010 TOMITA Masahiro
# mailto:tommy@tmtm.org
# License: Ruby's
*/
lib/node-mysql/mysql/sha1.js deleted 100644 → 0
/*
* The JavaScript implementation of the Secure Hash Algorithm 1
*
* Copyright (c) 2008 Takanori Ishikawa <takanori.ishikawa@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the authors nor the names of its contributors
* may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* This is the javascript file for code which implements
* the Secure Hash Algorithm 1 as defined in FIPS 180-1 published April 17, 1995.
*
* Author: Takanori Ishikawa <takanori.ishikawa@gmail.com>
* Copyright: Takanori Ishikawa 2008
* License: BSD License (see above)
*
* NOTE:
* Only 8-bit string is supported, please use encodeURIComponent() function
* if you want to hash multibyte string.
*
* Supported Browsers:
* [Win] IE 6, Firefox 2
* [Mac] Safari 3, Firefox 2
*
* Usage:
* var hexdigest = new SHA1("Hello.").hexdigest(); // "9b56d519ccd9e1e5b2a725e186184cdc68de0731"
*
* See Also:
* FIPS 180-1 - Secure Hash Standard
* http://www.itl.nist.gov/fipspubs/fip180-1.htm
*
*/
var SHA1 = (function(){
/**
* Spec is the BDD style test utilities.
*/
var Spec = {
/** Replace the Spec.describe function with empty function if false. */
enabled: true,
/** Indicates whether object 'a' is "equal to" 'b'. */
equals: function(a, b) {
if (a instanceof Array && b instanceof Array) {
if (a.length != b.length) return false;
for (var i = 0; i < a.length; i++) if (!Spec.equals(a[i], b[i])) return false;
return true;
}
if ((a != null && b != null) && (typeof a == "object" && typeof b == "object")) {
for (var i in a) if (!Spec.equals(a[i], b[i])) return false;
return true;
}
return (a == b);
},
/** equivalent to xUint's assert */
should: function(expection, message) {
Spec.currentIndicator++;
if (!expection) {
var warning = [
"[Spec failed",
Spec.currentTitle ? " (" + Spec.currentTitle + ")] " : "] ",
(message || (Spec.currentMessage + " " + Spec.currentIndicator) || "")
].join("");
alert(warning);
throw warning;
}
return !!expection;
},
/** Write your specification by using describe method. */
describe: function(title, spec) {
Spec.currentTitle = title;
for (var name in spec) {
Spec.currentMessage = name;
Spec.currentIndicator = 0;
spec[name]();
Spec.currentIndicator = null;
}
Spec.currentMessage = Spec.currentTitle = null;
},
Version: "0.1"
};
// Other BDD style stuffs.
Spec.should.equal = function(a, b, message) { return Spec.should(Spec.equals(a, b), message); };
Spec.should.not = function(a, message) { return Spec.should(!a, message); };
Spec.should.not.equal = function(a, b, message) { return Spec.should(!Spec.equals(a, b), message); };
if (!Spec.enabled) Spec.describe = function(){};
// self test
Spec.describe("Spec object", {
"should": function() {
Spec.should(true);
Spec.should(1);
},
"should.not": function() {
Spec.should.not(false);
Spec.should.not(0);
},
"should.equal": function() {
Spec.should.equal(null, null);
Spec.should.equal("", "");
Spec.should.equal(12345, 12345);
Spec.should.equal([0,1,2], [0,1,2]);
Spec.should.equal([0,1,[0,1,2]], [0,1,[0,1,2]]);
Spec.should.equal({}, {});
Spec.should.equal({x:1}, {x:1});
Spec.should.equal({x:[1]}, {x:[1]});
},
"should.not.equal": function() {
Spec.should.not.equal([1,2,3], [1,2,3,4]);
Spec.should.not.equal({x:1}, [1,2,3,4]);
}
});
// -----------------------------------------------------------
// Utilities
// -----------------------------------------------------------
// int32 -> hexdigits string (e.g. 0x123 -> '00000123')
function strfhex32(i32) {
i32 &= 0xffffffff;
if (i32 < 0) i32 += 0x100000000;
var hex = Number(i32).toString(16);
if (hex.length < 8) hex = "00000000".substr(0, 8 - hex.length) + hex;
return hex;
}
Spec.describe("sha1", {
"strfhex32": function() {
Spec.should.equal(strfhex32(0x0), "00000000");
Spec.should.equal(strfhex32(0x123), "00000123");
Spec.should.equal(strfhex32(0xffffffff), "ffffffff");
}
});
// int32 -> string (e.g. 123 -> '00000000 00000000 00000000 01111011')
function strfbits(i32) {
if (typeof arguments.callee.ZERO32 == 'undefined') {
arguments.callee.ZERO32 = new Array(33).join("0");
}
var bits = Number(i32).toString(2);
// '0' padding
if (bits.length < 32) bits = arguments.callee.ZERO32.substr(0, 32 - bits.length) + bits;
// split by 8 bits
return bits.replace(/(\d{8})/g, '$1 ')
.replace(/^\s*(.*?)\s*$/, '$1');
}
Spec.describe("sha1", {
"strfbits": function() {
Spec.should.equal(strfbits(0), "00000000 00000000 00000000 00000000");
Spec.should.equal(strfbits(1), "00000000 00000000 00000000 00000001");
Spec.should.equal(strfbits(123), "00000000 00000000 00000000 01111011");
}
});
// -----------------------------------------------------------
// SHA-1
// -----------------------------------------------------------
// Returns Number(32bit unsigned integer) array size to fit for blocks (512-bit strings)
function padding_size(nbits) {
var n = nbits + 1 + 64
return 512 * Math.ceil(n / 512) / 32;
}
Spec.describe("sha1", {
"padding_size": function() {
Spec.should.equal(padding_size(0), 16);
Spec.should.equal(padding_size(1), 16);
Spec.should.equal(padding_size(512 - 64 - 1), 16);
Spec.should.equal(padding_size(512 - 64), 32);
}
});
// 8bit string -> uint32[]
function word_array(m) {
var nchar = m.length;
var size = padding_size(nchar * 8);
var words = new Array(size);
for (var i = 0, j = 0; i < nchar; ) {
words[j++] = ((m.charCodeAt(i++) & 0xff) << 24) |
((m.charCodeAt(i++) & 0xff) << 16) |
((m.charCodeAt(i++) & 0xff) << 8) |
((m.charCodeAt(i++) & 0xff))
}
while (j < size) words[j++] = 0;
return words;
}
Spec.describe("sha1", {
"word_array": function() {
Spec.should.equal(word_array(""), [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]);
Spec.should.equal(word_array("1234")[0], 0x31323334);
}
});
function write_nbits(words, length, nbits) {
if (nbits > 0xffffffff) {
var lo = nbits & 0xffffffff;
if (lo < 0) lo += 0x100000000;
words[length - 1] = lo;
words[length - 2] = (nbits - lo) / 0x100000000;
} else {
words[length - 1] = nbits;
words[length - 2] = 0x0;
}
return words;
}
Spec.describe("sha1", {
"write_nbits": function() {
Spec.should.equal(write_nbits([0, 0], 2, 1), [0, 1]);
Spec.should.equal(write_nbits([0, 0], 2, 0xffffffff), [0, 0xffffffff]);
Spec.should.equal(write_nbits([0, 0], 2, 0x100000000), [1, 0]);
Spec.should.equal(write_nbits([0, 0], 2, 0x1ffffffff), [1, 0xffffffff]);
Spec.should.equal(write_nbits([0, 0], 2, 0x12300000000), [0x123, 0]);
Spec.should.equal(write_nbits([0, 0], 2, 0x123abcdef12), [0x123, 0xabcdef12]);
}
});
function padding(words, nbits) {
var i = Math.floor(nbits / 32);
words[i] |= (1 << (((i + 1) * 32) - nbits - 1));
write_nbits(words, padding_size(nbits), nbits);
return words;
}
function digest(words) {
var i = 0, t = 0;
var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
while (i < words.length) {
var W = new Array(80);
// (a)
for (t = 0; t < 16; t++) W[t] = words[i++];
// (b)
for (t = 16; t < 80; t++) {
var w = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16];
W[t] = (w << 1) | (w >>> 31);
}
// (c)
var A = H[0], B = H[1], C = H[2], D = H[3], E = H[4];
// (d) TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;
// E = D; D = C; C = S30(B); B = A; A = TEMP;
for (t = 0; t < 80; t++) {
var tmp = ((A << 5) | (A >>> 27)) + E + W[t];
if (t >= 0 && t <= 19) tmp += ((B & C) | ((~B) & D)) + 0x5a827999;
else if (t >= 20 && t <= 39) tmp += (B ^ C ^ D) + 0x6ed9eba1;
else if (t >= 40 && t <= 59) tmp += ((B & C) | (B & D) | (C & D)) + 0x8f1bbcdc;
else if (t >= 60 && t <= 79) tmp += (B ^ C ^ D) + 0xca62c1d6;
E = D; D = C; C = ((B << 30) | (B >>> 2)); B = A; A = tmp;
}
// (e) H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
H[0] = (H[0] + A) & 0xffffffff;
H[1] = (H[1] + B) & 0xffffffff;
H[2] = (H[2] + C) & 0xffffffff;
H[3] = (H[3] + D) & 0xffffffff;
H[4] = (H[4] + E) & 0xffffffff;
if (H[0] < 0) H[0] += 0x100000000;
if (H[1] < 0) H[1] += 0x100000000;
if (H[2] < 0) H[2] += 0x100000000;
if (H[3] < 0) H[3] += 0x100000000;
if (H[4] < 0) H[4] += 0x100000000;
}
return H;
}
// message: 8bit string
var SHA1 = function(message) {
this.message = message;
}
SHA1.prototype = {
digest: function() {
var nbits = this.message.length * 8;
var words = padding(word_array(this.message), nbits);
return digest(words);
},
hexdigest: function() {
var digest = this.digest();
for (var i = 0; i < digest.length; i++) digest[i] = strfhex32(digest[i]);
return digest.join("");
}
};
Spec.describe("sha1", {
"SHA1#hexdigest": function() {
Spec.should.equal(new SHA1("").hexdigest(), "da39a3ee5e6b4b0d3255bfef95601890afd80709");
Spec.should.equal(new SHA1("1").hexdigest(), "356a192b7913b04c54574d18c28d46e6395428ab");
Spec.should.equal(new SHA1("Hello.").hexdigest(), "9b56d519ccd9e1e5b2a725e186184cdc68de0731");
Spec.should.equal(new SHA1("9b56d519ccd9e1e5b2a725e186184cdc68de0731").hexdigest(), "f042dc98a62cbad68dbe21f11bbc1e9d416d2bf6");
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");
}
});
return SHA1;
})();
exports.SHA1 = SHA1; // add for node.js
lib/node-mysql/mysql/types.js deleted 100644 → 0
var constants = require('./constants');
var Time = function(year, month, day, hour, minute, second, neg, second_part) {
this.year = year || 0;
this.month = month || 0;
this.day = day || 0;
this.hour = hour || 0;
this.minute = minute || 0;
this.second = second || 0;
this.neg = !!neg;
this.second_part = second_part;
return this;
}
exports.Time = Time;
Time.prototype.toString = function() {
var date = [this.year, this.month, this.day].join("-");
var time = [this.hour, this.minute, this.second].join(":");
if(date=='0-0-0') return time;
return [date, time].join(' ');
}
Time.prototype.equals = function(obj) {
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;
}
var convertToSQLString = function(val) {
switch(typeof(val)) {
case 'undefined':
return 'NULL';
case 'string':
return "'"+quote(val)+"'"
case 'boolean':
return val?'true':'false';
case 'number':
return String(val);
}
if(val.join) { // if array
return convertToSQLString(val.join(','));
}
return "'"+quote(String(val))+"'";
}
exports.convertToSQLString = convertToSQLString;
var quote = function(str) {
return str.replace(/[\0\n\r\\\'\"\x1a]/g, function(s) {
switch(s) {
case "\0":
return "\\0";
case "\n":
return "\\n";
case "\r":
return "\\r";
case "\x1a":
return "\\Z";
default:
return "\\"+s;
}
});
}
exports.quote = quote;
var parseTime = function(val) {
var part = val.match(/^(0*(\d+) |)0*(\d+):0*(\d+):+0*(\d+)/);
if(part) {
part = part.map(function(s) {
return typeof(s)=='undefined' ? 0 : parseInt(s);
});
return new Time(0, 0, part[2], part[3], part[4], part[5]);
}
var part = val.match(/^(0*(\d+)-0*(\d+)-|)0*(\d+) *(0*(\d+):0*(\d+):+0*(\d+)|)/);
if(part) {
part = part.map(function(s) {
return typeof(s)=='undefined' ? 0 : parseInt(s);
});
return new Time(part[2], part[3], part[4], part[6], part[7], part[8]);
}
return undefined;
}
var Types = {};
Types[constants.field.TYPE_DECIMAL] = {
id: constants.field.TYPE_DECIMAL,
name: 'DECIMAL',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseFloat(val);
}
};
Types[constants.field.TYPE_TINY] = {
id: constants.field.TYPE_TINY,
name: 'TINY',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_SHORT] = {
id: constants.field.TYPE_SHORT,
name: 'SHORT',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_LONG] = {
id: constants.field.TYPE_LONG,
name: 'LONG',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_FLOAT] = {
id: constants.field.TYPE_FLOAT,
name: 'FLOAT',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseFloat(val);
}
};
Types[constants.field.TYPE_DOUBLE] = {
id: constants.field.TYPE_DOUBLE,
name: 'DOUBLE',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseFloat(val);
}
};
Types[constants.field.TYPE_NULL] = {
id: constants.field.TYPE_NULL,
name: 'NULL',
convert: function(val, charset, field) {
return null;
}
};
Types[constants.field.TYPE_TIMESTAMP] = {
id: constants.field.TYPE_TIMESTAMP,
name: 'TIMESTAMP',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseTime(val);
}
};
Types[constants.field.TYPE_LONGLONG] = {
id: constants.field.TYPE_LONGLONG,
name: 'LONGLONG',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_INT24] = {
id: constants.field.TYPE_INT24,
name: 'INT24',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_DATE] = {
id: constants.field.TYPE_DATE,
name: 'DATE',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseTime(val);
}
};
Types[constants.field.TYPE_TIME] = {
id: constants.field.TYPE_TIME,
name: 'TIME',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseTime(val);
}
};
Types[constants.field.TYPE_DATETIME] = {
id: constants.field.TYPE_DATETIME,
name: 'DATETIME',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseTime(val);
}
};
Types[constants.field.TYPE_YEAR] = {
id: constants.field.TYPE_YEAR,
name: 'YEAR',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseInt(val);
}
};
Types[constants.field.TYPE_NEWDATE] = {
id: constants.field.TYPE_NEWDATE,
name: 'NEWDATE',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseTime(val);
}
};
Types[constants.field.TYPE_VARCHAR] = {
id: constants.field.TYPE_VARCHAR,
name: 'VARCHAR',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_BIT] = {
id: constants.field.TYPE_BIT,
name: 'BIT',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : val;
}
};
Types[constants.field.TYPE_NEWDECIMAL] = {
id: constants.field.TYPE_NEWDECIMAL,
name: 'NEWDECIMAL',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : parseFloat(val);
}
};
Types[constants.field.TYPE_ENUM] = {
id: constants.field.TYPE_ENUM,
name: 'ENUM',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_SET] = {
id: constants.field.TYPE_SET,
name: 'SET',
convert: function(val, charset, field) {
if(typeof(val)=='undefined') return undefined;
return val=='' ? [] : charset.convertFromBytes(val.split(','));
}
};
Types[constants.field.TYPE_TINY_BLOB] = {
id: constants.field.TYPE_TINY_BLOB,
name: 'TINY_BLOB',
convert: function(val, charset, field) {
if(field.flags & constants.field.BINARY_FLAG) return val;
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_MEDIUM_BLOB] = {
id: constants.field.TYPE_MEDIUM_BLOB,
name: 'MEDIUM_BLOB',
convert: function(val, charset, field) {
if(field.flags & constants.field.BINARY_FLAG) return val;
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_LONG_BLOB] = {
id: constants.field.TYPE_LONG_BLOB,
name: 'LONG_BLOB',
convert: function(val, charset, field) {
if(field.flags & constants.field.BINARY_FLAG) return val;
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_BLOB] = {
id: constants.field.TYPE_BLOB,
name: 'BLOB',
convert: function(val, charset, field) {
if(field.flags & constants.field.BINARY_FLAG) return val;
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_VAR_STRING] = {
id: constants.field.TYPE_VAR_STRING,
name: 'VAR_STRING',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_STRING] = {
id: constants.field.TYPE_STRING,
name: 'STRING',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : charset.convertFromBytes(val);
}
};
Types[constants.field.TYPE_GEOMETRY] = {
id: constants.field.TYPE_GEOMETRY,
name: 'GEOMETRY',
convert: function(val, charset, field) {
return typeof(val)=='undefined' ? null : val;
}
};
exports.Types = Types;
\ No newline at end of file
lib/node-mysql/mysql/utils.js deleted 100644 → 0
var scope = function(target, func) {
return function(){ return func.apply(target, arguments); }
}
exports.scope = scope;
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!