Node-mysql-libmysqlclient API
MySQL bindings for Node.js using libmysqlclient.
Check out the Github repo for the source and installation guide.
Extra information: Homepage, ChangeLog, Examples, Wiki.
|
|
mysql-libmysqlclient
|
./mysql-libmysqlclient.js
|
Create connection to database
param: String | null hostname param: String | null user param: String | null password param: String | null database param: Integer | null port param: String | null socket return: MysqlConnection
|
exports.createConnectionSync = function () {
var db = new binding.MysqlConnection();
if (arguments.length > 0) {
db.connectSync.apply(db, Array.prototype.slice.call(arguments, 0, 6));
}
return db;
};
|
mysql_bindings
|
./src/mysql_bindings.cc
|
Init V8 structures
Classes to populate in JavaScript:
- MysqlConnection
- MysqlResult
- MysqlStatement
|
extern "C" void init(Handle<Object> target) {
MysqlConnection::Init(target);
MysqlResult::Init(target);
MysqlStatement::Init(target);
}
|
mysql_bindings_connection
|
./src/mysql_bindings_connection.cc
|
Creates new MysqlConnection object
|
Handle<Value> MysqlConnection::New(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = new MysqlConnection();
conn->Wrap(args.This());
return args.This();
}
|
Gets last connect error number
|
Handle<Value> MysqlConnection::ConnectErrnoGetter(Local<String> property,
const AccessorInfo &info) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(info.Holder());
return scope.Close(Integer::New(conn->connect_errno));
}
|
Gets last connect error string
|
Handle<Value> MysqlConnection::ConnectErrorGetter(Local<String> property,
const AccessorInfo &info) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(info.Holder());
return scope.Close(V8STR(conn->connect_error ? conn->connect_error : ""));
}
|
Gets number of affected rows in previous operation
|
Handle<Value> MysqlConnection::AffectedRowsSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
my_ulonglong affected_rows = mysql_affected_rows(conn->_conn);
if (affected_rows == ((my_ulonglong)-1)) {
return scope.Close(Integer::New(-1));
}
return scope.Close(Integer::New(affected_rows));
}
|
Sets autocommit mode
param: Boolean mode return: Boolean
|
Handle<Value> MysqlConnection::AutoCommitSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_BOOL_ARG(0, autocomit)
if (mysql_autocommit(conn->_conn, autocomit)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Changes the user and causes the database to become the default
|
Handle<Value> MysqlConnection::ChangeUserSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, user)
if ( (args.Length() < 2) || (!args[0]->IsString()) ||
(!args[1]->IsString()) ) {
return THRTYPEEXC("Must give at least user and password as arguments");
}
String::Utf8Value password(args[1]->ToString());
if ( (args.Length() == 3) && (!args[2]->IsString()) ) {
return THRTYPEEXC("Must give string value as third argument, dbname");
}
String::Utf8Value dbname(args[2]->ToString());
bool r = mysql_change_user(conn->_conn,
*user,
args[1]->IsString() ? *password : NULL,
args[2]->IsString() ? *dbname : NULL);
if (r) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Commits the current transaction
|
Handle<Value> MysqlConnection::CommitSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
if (mysql_commit(conn->_conn)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
EIO wrapper functions for MysqlConnection::Connect
|
#ifndef MYSQL_NON_THREADSAFE
int MysqlConnection::EIO_After_Connect(eio_req *req) {
ev_unref(EV_DEFAULT_UC);
HandleScope scope;
struct connect_request *conn_req = (struct connect_request *)(req->data);
Local<Value> argv[1];
if (req->result) {
int error_string_length = strlen(conn_req->conn->connect_error) + 25;
char* error_string = new char[error_string_length];
snprintf(error_string, error_string_length, "Connection error #%d: %s",
conn_req->errno, conn_req->error);
argv[0] = V8EXC(error_string);
delete[] error_string;
} else {
argv[0] = Local<Value>::New(Null());
}
TryCatch try_catch;
conn_req->callback->Call(Context::GetCurrent()->Global(), 1, argv);
if (try_catch.HasCaught()) {
node::FatalException(try_catch);
}
conn_req->callback.Dispose();
conn_req->conn->Unref();
free(conn_req);
return 0;
}
int MysqlConnection::EIO_Connect(eio_req *req) {
struct connect_request *conn_req = (struct connect_request *)(req->data);
req->result = conn_req->conn->Connect(
conn_req->hostname ? **(conn_req->hostname) : NULL,
conn_req->user ? **(conn_req->user) : NULL,
conn_req->password ? **(conn_req->password) : NULL,
conn_req->dbname ? **(conn_req->dbname) : NULL,
conn_req->port,
conn_req->socket ? **(conn_req->socket) : NULL,
conn_req->flags) ? 0 : 1;
if (req->result) {
conn_req->errno = conn_req->conn->connect_errno;
conn_req->error = conn_req->conn->connect_error;
}
delete conn_req->hostname;
delete conn_req->user;
delete conn_req->password;
delete conn_req->socket;
return 0;
}
#endif
|
Opens a new connection to the MySQL server
param: String | null hostname param: String | null user param: String | null password param: String | null database param: Integer | null port param: String | null socket param: Function(error) callback
|
Handle<Value> MysqlConnection::Connect(const Arguments& args) {
HandleScope scope;
#ifdef MYSQL_NON_THREADSAFE
return THREXC(MYSQL_NON_THREADSAFE_ERRORSTRING);
#else
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
struct connect_request *conn_req =
(struct connect_request *)calloc(1, sizeof(struct connect_request));
if (!conn_req) {
V8::LowMemoryNotification();
return THREXC("Could not allocate enough memory");
}
REQ_FUN_ARG(args.Length() - 1, callback);
conn_req->callback = Persistent<Function>::New(callback);
conn_req->conn = conn;
conn_req->hostname = args.Length() > 1 && args[0]->IsString() ?
new String::Utf8Value(args[0]->ToString()) : NULL;
conn_req->user = args.Length() > 2 && args[1]->IsString() ?
new String::Utf8Value(args[1]->ToString()) : NULL;
conn_req->password = args.Length() > 3 && args[2]->IsString() ?
new String::Utf8Value(args[2]->ToString()) : NULL;
conn_req->dbname = args.Length() > 4 && args[3]->IsString() ?
new String::Utf8Value(args[3]->ToString()) : NULL;
conn_req->port = args.Length() > 5 && args[4]->IsUint32() ?
args[4]->Uint32Value() : 0;
conn_req->socket = args.Length() > 6 && args[5]->IsString() ?
new String::Utf8Value(args[5]->ToString()) : NULL;
conn_req->flags = args.Length() > 7 && args[6]->IsUint32() ?
args[6]->Uint32Value() : 0;
eio_custom(EIO_Connect, EIO_PRI_DEFAULT, EIO_After_Connect, conn_req);
ev_ref(EV_DEFAULT_UC);
conn->Ref();
return Undefined();
#endif
}
|
Opens a new connection to the MySQL server
param: String | null hostname param: String | null user param: String | null password param: String | null database param: Integer | null port param: String | null socket return: Boolean
|
Handle<Value> MysqlConnection::ConnectSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
if (conn->_conn) {
return THREXC("Already initialized. "
"Use conn.realConnectSync() after conn.initSync()");
}
String::Utf8Value hostname(args[0]->ToString());
String::Utf8Value user(args[1]->ToString());
String::Utf8Value password(args[2]->ToString());
String::Utf8Value dbname(args[3]->ToString());
uint32_t port = args[4]->Uint32Value();
String::Utf8Value socket(args[5]->ToString());
uint64_t flags = args[6]->Uint32Value();
bool r = conn->Connect(args[0]->IsString() ? *hostname : NULL,
args[1]->IsString() ? *user : NULL,
args[2]->IsString() ? *password : NULL,
args[3]->IsString() ? *dbname : NULL,
args[4]->IsUint32() ? port : 0,
args[5]->IsString() ? *socket : NULL,
args[6]->IsUint32() ? flags : 0);
if (!r) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Returns current connected status
|
Handle<Value> MysqlConnection::ConnectedSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
return scope.Close(conn->connected ? True() : False());
}
|
Closes database connection
|
Handle<Value> MysqlConnection::CloseSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
conn->Close();
return Undefined();
}
|
Performs debugging operations
|
Handle<Value> MysqlConnection::DebugSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, debug)
mysql_debug(*debug);
return Undefined();
}
|
Dump debugging information into the log
|
Handle<Value> MysqlConnection::DumpDebugInfoSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
return scope.Close(mysql_dump_debug_info(conn->_conn) ? False() : True());
}
|
Returns the last error code
|
Handle<Value> MysqlConnection::ErrnoSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
return scope.Close(Integer::New(mysql_errno(conn->_conn)));
}
|
Returns a string description of the last error
|
Handle<Value> MysqlConnection::ErrorSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
const char *error = mysql_error(conn->_conn);
return scope.Close(V8STR(error));
}
|
Escapes special characters in a string for use in an SQL statement,
taking into account the current charset of the connection
param: String string return: String
|
Handle<Value> MysqlConnection::EscapeSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, str)
int len = str.length();
char *result = new char[2*len + 1];
if (!result) {
V8::LowMemoryNotification();
return THREXC("Not enough memory");
}
mysql_real_escape_string(conn->_conn, result, *str, len);
Local<Value> js_result = V8STR(result);
delete[] result;
return scope.Close(js_result);
}
|
Returns the number of columns for the most recent query
|
Handle<Value> MysqlConnection::FieldCountSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
return scope.Close(Integer::New(mysql_field_count(conn->_conn)));
}
|
Returns a character set object
|
Handle<Value> MysqlConnection::GetCharsetSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
MY_CHARSET_INFO cs;
mysql_get_character_set_info(conn->_conn, &cs);
Local<Object> js_result = Object::New();
js_result->Set(V8STR("charset"), V8STR(cs.csname ? cs.csname : ""));
js_result->Set(V8STR("collation"), V8STR(cs.name ? cs.name : ""));
js_result->Set(V8STR("dir"), V8STR(cs.dir ? cs.dir : ""));
js_result->Set(V8STR("min_length"), Integer::New(cs.mbminlen));
js_result->Set(V8STR("max_length"), Integer::New(cs.mbmaxlen));
js_result->Set(V8STR("number"), Integer::New(cs.number));
js_result->Set(V8STR("state"), Integer::New(cs.state));
js_result->Set(V8STR("comment"), V8STR(cs.comment ? cs.comment : ""));
return scope.Close(js_result);
}
|
Returns a character set name
|
Handle<Value> MysqlConnection::GetCharsetNameSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
return scope.Close(V8STR(mysql_character_set_name(conn->_conn)));
}
|
Returns the MySQL client version and information
|
Handle<Value> MysqlConnection::GetClientInfoSync(const Arguments& args) {
HandleScope scope;
Local<Object> js_result = Object::New();
js_result->Set(V8STR("client_info"),
V8STR(mysql_get_client_info()));
js_result->Set(V8STR("client_version"),
Integer::New(mysql_get_client_version()));
return scope.Close(js_result);
}
|
Returns the MySQL client, server, host and protocol version and information
|
Handle<Value> MysqlConnection::GetInfoSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
Local<Object> js_result = Object::New();
js_result->Set(V8STR("client_info"),
V8STR(mysql_get_client_info()));
js_result->Set(V8STR("client_version"),
Integer::New(mysql_get_client_version()));
js_result->Set(V8STR("server_info"),
V8STR(mysql_get_server_info(conn->_conn)));
js_result->Set(V8STR("server_version"),
Integer::New(mysql_get_server_version(conn->_conn)));
js_result->Set(V8STR("host_info"),
V8STR(mysql_get_host_info(conn->_conn)));
js_result->Set(V8STR("proto_info"),
Integer::New(mysql_get_proto_info(conn->_conn)));
return scope.Close(js_result);
}
|
Retrieves information about the most recently executed query
|
Handle<Value> MysqlConnection::GetInfoStringSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
const char *info = mysql_info(conn->_conn);
return scope.Close(V8STR(info ? info : ""));
}
|
Gets result of SHOW WARNINGS
|
Handle<Value> MysqlConnection::GetWarningsSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
MYSQL_RES *result;
MYSQL_ROW row;
int i = 0;
Local<Object> js_warning = Object::New();
Local<Array> js_result = Array::New();
if (mysql_warning_count(conn->_conn)) {
if (mysql_real_query(conn->_conn, "SHOW WARNINGS", 13) == 0) {
result = mysql_store_result(conn->_conn);
while ((row = mysql_fetch_row(result))) {
js_warning->Set(V8STR("errno"), V8STR(row[1])->ToInteger());
js_warning->Set(V8STR("reason"), V8STR(row[2]));
js_result->Set(Integer::New(i), js_warning);
i++;
}
mysql_free_result(result);
}
}
return scope.Close(js_result);
}
|
Initializes MysqlConnection
|
Handle<Value> MysqlConnection::InitSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
if (conn->_conn) {
return THREXC("Already initialized");
}
conn->_conn = mysql_init(NULL);
if (!conn->_conn) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Initializes a statement and returns it
|
Handle<Value> MysqlConnection::InitStatementSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQL_STMT *my_statement = mysql_stmt_init(conn->_conn);
if (!my_statement) {
return scope.Close(False());
}
Local<Value> arg = External::New(my_statement);
Persistent<Object> js_result(MysqlStatement::constructor_template->
GetFunction()->NewInstance(1, &arg));
return scope.Close(js_result);
}
|
Returns the auto generated id used in the last query
|
Handle<Value> MysqlConnection::LastInsertIdSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
MYSQL_RES *result;
my_ulonglong insert_id = 0;
if ( (result = mysql_store_result(conn->_conn)) == 0 &&
mysql_field_count(conn->_conn) == 0 &&
mysql_insert_id(conn->_conn) != 0) {
insert_id = mysql_insert_id(conn->_conn);
}
return scope.Close(Integer::New(insert_id));
}
|
Checks if there are any more query results from a multi query
|
Handle<Value> MysqlConnection::MultiMoreResultsSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
if (mysql_more_results(conn->_conn)) {
return scope.Close(True());
}
return scope.Close(False());
}
|
Prepare next result from multi_query
|
Handle<Value> MysqlConnection::MultiNextResultSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
if (!mysql_more_results(conn->_conn)) {
return THREXC("There is no next result set."
"Please, call MultiMoreResultsSync() to check "
"whether to call this function/method");
}
if (!mysql_next_result(conn->_conn)) {
return scope.Close(True());
}
return scope.Close(False());
}
|
Performs a multi_query on the database
|
Handle<Value> MysqlConnection::MultiRealQuerySync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
REQ_STR_ARG(0, query)
MYSQLCONN_MUSTBE_CONNECTED;
MYSQLCONN_ENABLE_MQ;
if (mysql_real_query(conn->_conn, *query, query.length()) != 0) {
MYSQLCONN_DISABLE_MQ;
return scope.Close(False());
}
MYSQLCONN_DISABLE_MQ;
return scope.Close(True());
}
|
Pings a server connection,
or tries to reconnect if the connection has gone down
|
Handle<Value> MysqlConnection::PingSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
if (mysql_ping(conn->_conn)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
EIO wrapper functions for MysqlConnection::Query
|
#ifndef MYSQL_NON_THREADSAFE
int MysqlConnection::EIO_After_Query(eio_req *req) {
ev_unref(EV_DEFAULT_UC);
HandleScope scope;
struct query_request *query_req = (struct query_request *)(req->data);
int argc = 1;
Local<Value> argv[3];
if (req->result) {
int error_string_length = strlen(query_req->error) + 20;
char* error_string = new char[error_string_length];
snprintf(error_string, error_string_length, "Query error #%d: %s",
query_req->errno, query_req->error);
argv[0] = V8EXC(error_string);
delete[] error_string;
} else {
if (req->int1) {
argv[0] = External::New(query_req->conn->_conn);
argv[1] = External::New(query_req->my_result);
argv[2] = Integer::New(query_req->field_count);
Persistent<Object> js_result(MysqlResult::constructor_template->
GetFunction()->NewInstance(3, argv));
argv[1] = Local<Value>::New(scope.Close(js_result));
} else {
Local<Object> js_result = Object::New();
js_result->Set(V8STR("affectedRows"),
Integer::New(query_req->affected_rows));
js_result->Set(V8STR("insertId"),
Integer::New(query_req->insert_id));
argv[1] = Local<Object>::New(scope.Close(js_result));
}
argc = 2;
argv[0] = Local<Value>::New(Null());
}
if (query_req->callback->IsFunction()) {
TryCatch try_catch;
Persistent<Function>::Cast(query_req->callback)->
Call(Context::GetCurrent()->Global(), argc, argv);
if (try_catch.HasCaught()) {
node::FatalException(try_catch);
}
query_req->callback.Dispose();
}
query_req->conn->Unref();
free(query_req->query);
free(query_req);
return 0;
}
int MysqlConnection::EIO_Query(eio_req *req) {
struct query_request *query_req = (struct query_request *)(req->data);
MysqlConnection *conn = query_req->conn;
if (!conn->_conn) {
req->result = 1;
return 0;
}
MYSQLCONN_DISABLE_MQ;
pthread_mutex_lock(&conn->query_lock);
int r = mysql_query(conn->_conn, query_req->query);
if (r != 0) {
req->result = 1;
query_req->errno = mysql_errno(conn->_conn);
query_req->error = mysql_error(conn->_conn);
} else {
req->result = 0;
MYSQL_RES *my_result = mysql_store_result(conn->_conn);
query_req->field_count = mysql_field_count(conn->_conn);
if (my_result) {
req->int1 = 1;
query_req->my_result = my_result;
} else {
if (query_req->field_count == 0) {
query_req->affected_rows = mysql_affected_rows(conn->_conn);
query_req->insert_id = mysql_insert_id(conn->_conn);
req->int1 = 0;
} else {
req->result = 1;
}
}
}
pthread_mutex_unlock(&conn->query_lock);
return 0;
}
#endif
|
Performs a query on the database
|
Handle<Value> MysqlConnection::Query(const Arguments& args) {
HandleScope scope;
#ifdef MYSQL_NON_THREADSAFE
return THREXC(MYSQL_NON_THREADSAFE_ERRORSTRING);
#else
REQ_STR_ARG(0, query);
OPTIONAL_FUN_ARG(1, callback);
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
struct query_request *query_req = (struct query_request *)
calloc(1, sizeof(struct query_request));
if (!query_req) {
V8::LowMemoryNotification();
return THREXC("Could not allocate enough memory");
}
query_req->query =
reinterpret_cast<char *>(calloc(query.length() + 1,
sizeof(char)));
if (snprintf(query_req->query, query.length() + 1, "%s", *query) !=
query.length()) {
return THREXC("Snprintf() error");
}
query_req->callback = Persistent<Value>::New(callback);
query_req->conn = conn;
eio_custom(EIO_Query, EIO_PRI_DEFAULT, EIO_After_Query, query_req);
ev_ref(EV_DEFAULT_UC);
conn->Ref();
return Undefined();
#endif
}
|
Performs a query on the database
|
Handle<Value> MysqlConnection::QuerySync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
REQ_STR_ARG(0, query)
MYSQLCONN_MUSTBE_CONNECTED;
MYSQLCONN_DISABLE_MQ;
MYSQL_RES *my_result = NULL;
int field_count;
pthread_mutex_lock(&conn->query_lock);
int r = mysql_query(conn->_conn, *query);
if (r == 0) {
my_result = mysql_store_result(conn->_conn);
field_count = mysql_field_count(conn->_conn);
}
pthread_mutex_unlock(&conn->query_lock);
if (r != 0) {
return scope.Close(False());
}
if (!my_result) {
if (field_count == 0) {
return scope.Close(True());
} else {
return scope.Close(False());
}
}
int argc = 3;
Local<Value> argv[argc];
argv[0] = External::New(conn->_conn);
argv[1] = External::New(my_result);
argv[2] = Integer::New(field_count);
Persistent<Object> js_result(MysqlResult::constructor_template->
GetFunction()->NewInstance(argc, argv));
return scope.Close(js_result);
}
|
Rolls back current transaction
|
Handle<Value> MysqlConnection::RollbackSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
if (mysql_rollback(conn->_conn)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Opens a new connection to the MySQL server
param: String | null hostname param: String | null user param: String | null password param: String | null database param: Integer | null port param: String | null socket return: Boolean
|
Handle<Value> MysqlConnection::RealConnectSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_INITIALIZED;
String::Utf8Value hostname(args[0]->ToString());
String::Utf8Value user(args[1]->ToString());
String::Utf8Value password(args[2]->ToString());
String::Utf8Value dbname(args[3]->ToString());
uint32_t port = args[4]->Uint32Value();
String::Utf8Value socket(args[5]->ToString());
uint64_t flags = args[6]->Uint32Value();
bool r = conn->RealConnect(args[0]->IsString() ? *hostname : NULL,
args[1]->IsString() ? *user : NULL,
args[2]->IsString() ? *password : NULL,
args[3]->IsString() ? *dbname : NULL,
args[4]->IsUint32() ? port : 0,
args[5]->IsString() ? *socket : NULL,
args[6]->IsUint32() ? flags : 0);
if (!r) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Executes an SQL query
param: String query return: Boolean
|
Handle<Value> MysqlConnection::RealQuerySync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
REQ_STR_ARG(0, query)
MYSQLCONN_MUSTBE_CONNECTED;
MYSQLCONN_DISABLE_MQ;
pthread_mutex_lock(&conn->query_lock);
int r = mysql_real_query(conn->_conn, *query, query.length());
pthread_mutex_unlock(&conn->query_lock);
if (r != 0) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Selects the default database for database queries
param: String database return: Boolean
|
Handle<Value> MysqlConnection::SelectDbSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, dbname)
if (mysql_select_db(conn->_conn, *dbname)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Sets the default client character set
param: String charset return: Boolean
|
Handle<Value> MysqlConnection::SetCharsetSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, charset)
if (mysql_set_character_set(conn->_conn, *charset)) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Sets options
|
Handle<Value> MysqlConnection::SetOptionSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
REQ_INT_ARG(0, option_integer_key);
mysql_option option_key = static_cast<mysql_option>(option_integer_key);
int r = 1;
switch (option_key) {
case MYSQL_OPT_CONNECT_TIMEOUT:
case MYSQL_OPT_PROTOCOL:
case MYSQL_OPT_READ_TIMEOUT:
case MYSQL_OPT_WRITE_TIMEOUT:
case MYSQL_OPT_RECONNECT:
case MYSQL_OPT_COMPRESS:
case MYSQL_OPT_SSL_VERIFY_SERVER_CERT:
case MYSQL_REPORT_DATA_TRUNCATION:
case MYSQL_SECURE_AUTH:
{
REQ_INT_ARG(1, option_integer_value);
r = mysql_options(conn->_conn,
option_key,
static_cast<const char *>(
static_cast<const void *>(
&option_integer_value)));
#if MYSQL_VERSION_ID >= 50013 && MYSQL_VERSION_ID < 50106
if (!r && (option_key == MYSQL_OPT_RECONNECT)) {
conn->opt_reconnect = option_integer_value;
}
#endif
}
break;
case MYSQL_READ_DEFAULT_FILE:
case MYSQL_READ_DEFAULT_GROUP:
case MYSQL_INIT_COMMAND:
case MYSQL_SET_CHARSET_NAME:
case MYSQL_SET_CHARSET_DIR:
{
REQ_STR_ARG(1, option_string_value);
r = mysql_options(conn->_conn, option_key, *option_string_value);
}
break;
case MYSQL_OPT_LOCAL_INFILE:
return THREXC("This option isn't implemented yet");
break;
case MYSQL_OPT_NAMED_PIPE:
case MYSQL_SHARED_MEMORY_BASE_NAME:
return THREXC("This option isn't used because Windows");
break;
case MYSQL_OPT_GUESS_CONNECTION:
case MYSQL_SET_CLIENT_IP:
case MYSQL_OPT_USE_EMBEDDED_CONNECTION:
case MYSQL_OPT_USE_REMOTE_CONNECTION:
return THREXC("This option isn't used because not embedded");
break;
case MYSQL_OPT_USE_RESULT:
default:
return THREXC("This option isn't supported by MySQL");
}
if (r) {
return scope.Close(False());
}
return scope.Close(True());
}
|
Sets SSL options
Used for establishing secure connections
param: String key file param: String certificate file param: String certificate authority file param: String CA certificates in PEM directory param: String allowable ciphers
|
Handle<Value> MysqlConnection::SetSslSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
REQ_STR_ARG(0, key)
REQ_STR_ARG(1, cert)
REQ_STR_ARG(2, ca)
REQ_STR_ARG(3, capath)
REQ_STR_ARG(4, cipher)
mysql_ssl_set(conn->_conn, *key, *cert, *ca, *capath, *cipher);
return scope.Close(Undefined());
}
|
Returns the SQLSTATE error from previous MySQL operation
|
Handle<Value> MysqlConnection::SqlStateSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
return scope.Close(V8STR(mysql_sqlstate(conn->_conn)));
}
|
Gets the current system status
|
Handle<Value> MysqlConnection::StatSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
const char *stat = mysql_stat(conn->_conn);
return scope.Close(V8STR(stat ? stat : ""));
}
|
Transfers a result set from the last query
|
Handle<Value> MysqlConnection::StoreResultSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
if (!mysql_field_count(conn->_conn)) {
|
|
no result set - not a SELECT, SHOW, DESCRIBE or EXPLAIN,
|
|
return scope.Close(True());
}
MYSQL_RES *my_result = mysql_store_result(conn->_conn);
if (!my_result) {
return scope.Close(False());
}
int argc = 3;
Local<Value> argv[argc];
argv[0] = External::New(conn->_conn);
argv[1] = External::New(my_result);
argv[2] = Integer::New(mysql_field_count(conn->_conn));
Persistent<Object> js_result(MysqlResult::constructor_template->
GetFunction()->NewInstance(argc, argv));
return scope.Close(js_result);
}
|
Returns the thread ID for the current connection
|
Handle<Value> MysqlConnection::ThreadIdSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
uint64_t thread_id = mysql_thread_id(conn->_conn);
return scope.Close(Integer::New(thread_id));
}
|
Returns whether thread safety is given or not
|
Handle<Value> MysqlConnection::ThreadSafeSync(const Arguments& args) {
HandleScope scope;
if (mysql_thread_safe()) {
return scope.Close(True());
} else {
return scope.Close(False());
}
}
|
Initiates a result set retrieval
|
Handle<Value> MysqlConnection::UseResultSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
if (!mysql_field_count(conn->_conn)) {
|
|
no result set - not a SELECT, SHOW, DESCRIBE or EXPLAIN,
|
|
return scope.Close(True());
}
MYSQL_RES *my_result = mysql_use_result(conn->_conn);
if (!my_result) {
return scope.Close(False());
}
int argc = 3;
Local<Value> argv[argc];
argv[0] = External::New(conn->_conn);
argv[1] = External::New(my_result);
argv[2] = Integer::New(mysql_field_count(conn->_conn));
Persistent<Object> js_result(MysqlResult::constructor_template->
GetFunction()->NewInstance(argc, argv));
return scope.Close(js_result);
}
|
Returns the number of warnings from the last query for the given link
|
Handle<Value> MysqlConnection::WarningCountSync(const Arguments& args) {
HandleScope scope;
MysqlConnection *conn = OBJUNWRAP<MysqlConnection>(args.This());
MYSQLCONN_MUSTBE_CONNECTED;
uint32_t warning_count = mysql_warning_count(conn->_conn);
return scope.Close(Integer::New(warning_count));
}
|
mysql_bindings_result
|
./src/mysql_bindings_result.cc
|
Creates new MysqlResult object
|
Handle<Value> MysqlResult::New(const Arguments& args) {
HandleScope scope;
REQ_EXT_ARG(0, js_connection);
REQ_EXT_ARG(1, js_result);
REQ_UINT_ARG(2, field_count);
MYSQL *connection = static_cast<MYSQL*>(js_connection->Value());
MYSQL_RES *result = static_cast<MYSQL_RES*>(js_result->Value());
MysqlResult *my_res = new MysqlResult(connection, result, field_count);
my_res->Wrap(args.This());
return args.This();
}
|
Get the number of fields in a result
|
Handle<Value> MysqlResult::FieldCountGetter(Local<String> property,
const AccessorInfo &info) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(info.Holder());
MYSQLRES_MUSTBE_VALID;
if (res->field_count > 0) {
return scope.Close(Integer::New(res->field_count));
} else {
return Undefined();
}
}
|
Adjusts the result pointer to an arbitary row in the result
|
Handle<Value> MysqlResult::DataSeekSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
REQ_UINT_ARG(0, offset)
if (mysql_result_is_unbuffered(res->_res)) {
return THREXC("Function cannot be used with MYSQL_USE_RESULT");
}
if (offset < 0 || offset >= mysql_num_rows(res->_res)) {
return THREXC("Invalid row offset");
}
mysql_data_seek(res->_res, offset);
return Undefined();
}
|
EIO wrapper functions for MysqlResult::FetchAll
|
#ifndef MYSQL_NON_THREADSAFE
int MysqlResult::EIO_After_FetchAll(eio_req *req) {
HandleScope scope;
ev_unref(EV_DEFAULT_UC);
struct fetchAll_request *fetchAll_req =
reinterpret_cast<struct fetchAll_request *>(req->data);
int argc = 1;
|
|
node.js convention, there is always one argument
|
|
Local<Value> argv[3];
if (req->result) {
argv[0] = V8EXC("Error on fetching fields");
} else {
MYSQL_FIELD *fields = fetchAll_req->fields;
uint32_t num_fields = fetchAll_req->num_fields;
MYSQL_ROW result_row;
uint32_t i = 0, j = 0;
Local<Array> js_result = Array::New();
Local<Object> js_result_row;
Local<Value> js_field;
i = 0;
while ( (result_row = mysql_fetch_row(fetchAll_req->res->_res)) &&
(i < num_fields) ) {
if (fetchAll_req->results_array) {
js_result_row = Array::New();
} else {
js_result_row = Object::New();
}
for (j = 0; j < num_fields; j++) {
js_field = GetFieldValue(fields[j], result_row[j]);
if (fetchAll_req->results_array) {
js_result_row->Set(Integer::New(j), js_field);
} else {
if (fetchAll_req->results_structured) {
if (!js_result_row->Has(V8STR(fields[j].table))) {
js_result_row->Set(V8STR(fields[j].table),
Object::New());
}
js_result_row->Get(V8STR(fields[j].table))->ToObject()
->Set(V8STR(fields[j].name), js_field);
} else {
js_result_row->Set(V8STR(fields[j].name), js_field);
}
}
}
js_result->Set(Integer::New(i), js_result_row);
i++;
}
if (i != mysql_num_rows(fetchAll_req->res->_res)) {
unsigned int errno = mysql_errno(fetchAll_req->res->_conn);
const char *error = mysql_error(fetchAll_req->res->_conn);
int error_string_length = strlen(error) + 20;
char* error_string = new char[error_string_length];
snprintf(error_string, error_string_length, "Fetch error #%d: %s",
errno, error);
argv[0] = V8EXC(error_string);
delete[] error_string;
} else {
Local<Array> js_fields = Array::New();
for (i = 0; i < num_fields; i++) {
js_result_row = Object::New();
AddFieldProperties(js_result_row, &fields[i]);
js_fields->Set(Integer::New(i), js_result_row);
}
argv[1] = js_result;
argv[2] = js_fields;
argv[0] = Local<Value>::New(Null());
argc = 3;
}
}
TryCatch try_catch;
fetchAll_req->callback->Call(Context::GetCurrent()->Global(), argc, argv);
if (try_catch.HasCaught()) {
node::FatalException(try_catch);
}
fetchAll_req->callback.Dispose();
fetchAll_req->res->Unref();
free(fetchAll_req);
return 0;
}
int MysqlResult::EIO_FetchAll(eio_req *req) {
struct fetchAll_request *fetchAll_req =
reinterpret_cast<struct fetchAll_request *>(req->data);
MysqlResult *res = fetchAll_req->res;
fetchAll_req->fields = mysql_fetch_fields(res->_res);
fetchAll_req->num_fields = mysql_num_fields(res->_res);
req->result = 0;
return 0;
}
#endif
|
Fetches all result rows as an array
|
Handle<Value> MysqlResult::FetchAll(const Arguments& args) {
HandleScope scope;
#ifdef MYSQL_NON_THREADSAFE
return THREXC(MYSQL_NON_THREADSAFE_ERRORSTRING);
#else
int arg_pos = 0;
bool results_array = false;
bool results_structured = false;
if (args.Length() > 0) {
if (args[0]->IsBoolean()) {
results_array = args[0]->BooleanValue();
arg_pos++;
} else if (args[0]->IsObject() && !args[0]->IsFunction()) {
if (args[0]->ToObject()->Has(V8STR("array"))) {
results_array = args[0]->ToObject()
->Get(V8STR("array"))->BooleanValue();
}
if (args[0]->ToObject()->Has(V8STR("structured"))) {
results_structured = args[0]->ToObject()
->Get(V8STR("structured"))->BooleanValue();
}
arg_pos++;
}
}
if (results_array && results_structured) {
return THREXC("You can't mix 'array' and 'structured' parameters");
}
REQ_FUN_ARG(arg_pos, callback)
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
struct fetchAll_request *fetchAll_req = (struct fetchAll_request *)
calloc(1, sizeof(struct fetchAll_request));
if (!fetchAll_req) {
V8::LowMemoryNotification();
return THREXC("Could not allocate enough memory");
}
fetchAll_req->callback = Persistent<Function>::New(callback);
fetchAll_req->res = res;
fetchAll_req->results_array = results_array;
fetchAll_req->results_structured = results_structured;
eio_custom(EIO_FetchAll, EIO_PRI_DEFAULT, EIO_After_FetchAll, fetchAll_req);
ev_ref(EV_DEFAULT_UC);
res->Ref();
return Undefined();
#endif
}
|
Fetches all result rows as an array
|
Handle<Value> MysqlResult::FetchAllSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
bool results_array = false;
bool results_structured = false;
if (args.Length() > 0) {
if (args[0]->IsBoolean()) {
results_array = args[0]->BooleanValue();
} else if (args[0]->IsObject()) {
if (args[0]->ToObject()->Has(V8STR("array"))) {
results_array = args[0]->ToObject()
->Get(V8STR("array"))->BooleanValue();
}
if (args[0]->ToObject()->Has(V8STR("structured"))) {
results_structured = args[0]->ToObject()
->Get(V8STR("structured"))->BooleanValue();
}
}
}
if (results_array && results_structured) {
return THREXC("You can't mix 'array' and 'structured' parameters");
}
MYSQL_FIELD *fields = mysql_fetch_fields(res->_res);
uint32_t num_fields = mysql_num_fields(res->_res);
MYSQL_ROW result_row;
uint32_t i = 0, j = 0;
Local<Array> js_result = Array::New();
Local<Object> js_result_row;
Local<Value> js_field;
i = 0;
while ( (result_row = mysql_fetch_row(res->_res)) ) {
if (results_array) {
js_result_row = Array::New();
} else {
js_result_row = Object::New();
}
for (j = 0; j < num_fields; j++) {
js_field = GetFieldValue(fields[j], result_row[j]);
if (results_array) {
js_result_row->Set(Integer::New(j), js_field);
} else {
if (results_structured) {
if (!js_result_row->Has(V8STR(fields[j].table))) {
js_result_row->Set(V8STR(fields[j].table),
Object::New());
}
js_result_row->Get(V8STR(fields[j].table))->ToObject()
->Set(V8STR(fields[j].name), js_field);
} else {
js_result_row->Set(V8STR(fields[j].name), js_field);
}
}
}
js_result->Set(Integer::New(i), js_result_row);
i++;
}
return scope.Close(js_result);
}
|
Fetch a result row as an array
|
Handle<Value> MysqlResult::FetchArraySync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
MYSQL_FIELD *fields = mysql_fetch_fields(res->_res);
uint32_t num_fields = mysql_num_fields(res->_res);
uint32_t j = 0;
Local<Array> js_result_row;
Local<Value> js_field;
MYSQL_ROW result_row = mysql_fetch_row(res->_res);
if (!result_row) {
return scope.Close(False());
}
js_result_row = Array::New();
for ( j = 0; j < num_fields; j++ ) {
js_field = GetFieldValue(fields[j], result_row[j]);
js_result_row->Set(Integer::New(j), js_field);
}
return scope.Close(js_result_row);
}
|
Returns meta-data of the next field in the result set
|
Handle<Value> MysqlResult::FetchFieldSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
MYSQL_FIELD *field;
Local<Object> js_result;
field = mysql_fetch_field(res->_res);
if (!field) {
return scope.Close(False());
}
js_result = Object::New();
AddFieldProperties(js_result, field);
return scope.Close(js_result);
}
|
Fetch meta-data for a single field
|
Handle<Value> MysqlResult::FetchFieldDirectSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
REQ_INT_ARG(0, field_num)
MYSQL_FIELD *field;
Local<Object> js_result;
field = mysql_fetch_field_direct(res->_res, field_num);
if (!field) {
return scope.Close(False());
}
js_result = Object::New();
AddFieldProperties(js_result, field);
return scope.Close(js_result);
}
|
Returns an array of objects representing the fields in a result set
|
Handle<Value> MysqlResult::FetchFieldsSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
uint32_t num_fields = mysql_num_fields(res->_res);
MYSQL_FIELD *field;
uint32_t i = 0;
Local<Array> js_result = Array::New();
Local<Object> js_result_obj;
for (i = 0; i < num_fields; i++) {
field = mysql_fetch_field_direct(res->_res, i);
js_result_obj = Object::New();
AddFieldProperties(js_result_obj, field);
js_result->Set(Integer::New(i), js_result_obj);
}
return scope.Close(js_result);
}
|
Returns the lengths of the columns of the current row in the result set
|
Handle<Value> MysqlResult::FetchLengthsSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
uint32_t num_fields = mysql_num_fields(res->_res);
unsigned long int *lengths = mysql_fetch_lengths(res->_res);
uint32_t i = 0;
Local<Array> js_result = Array::New();
if (!lengths) {
return scope.Close(False());
}
for (i = 0; i < num_fields; i++) {
js_result->Set(Integer::New(i), Integer::New(lengths[i]));
}
return scope.Close(js_result);
}
|
Fetch a result row as an object
|
Handle<Value> MysqlResult::FetchObjectSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
MYSQL_FIELD *fields = mysql_fetch_fields(res->_res);
uint32_t num_fields = mysql_num_fields(res->_res);
MYSQL_ROW result_row;
uint32_t j = 0;
Local<Object> js_result_row;
Local<Value> js_field;
result_row = mysql_fetch_row(res->_res);
if (!result_row) {
return scope.Close(False());
}
js_result_row = Object::New();
for ( j = 0; j < num_fields; j++ ) {
js_field = GetFieldValue(fields[j], result_row[j]);
js_result_row->Set(V8STR(fields[j].name), js_field);
}
return scope.Close(js_result_row);
}
|
Set result pointer to a specified field offset
|
Handle<Value> MysqlResult::FieldSeekSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
REQ_UINT_ARG(0, field_num)
if (field_num < 0 || field_num >= res->field_count) {
return THREXC("Invalid field offset");
}
mysql_field_seek(res->_res, field_num);
return Undefined();
}
|
Returns the position of the field cursor
|
Handle<Value> MysqlResult::FieldTellSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
return scope.Close(Integer::New(mysql_field_tell(res->_res)));
}
|
Frees the memory associated with a result
|
Handle<Value> MysqlResult::FreeSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
res->Free();
return Undefined();
}
|
Gets the number of rows in a result
|
Handle<Value> MysqlResult::NumRowsSync(const Arguments& args) {
HandleScope scope;
MysqlResult *res = OBJUNWRAP<MysqlResult>(args.This());
MYSQLRES_MUSTBE_VALID;
if (mysql_result_is_unbuffered(res->_res)) {
return THREXC("Function cannot be used with MYSQL_USE_RESULT");
}
return scope.Close(Integer::New(mysql_num_rows(res->_res)));
}
|
mysql_bindings_statement
|
./src/mysql_bindings_statement.cc
|
Create new MySQL statement object
|
Handle<Value> MysqlStatement::New(const Arguments& args) {
HandleScope scope;
REQ_EXT_ARG(0, js_stmt);
MYSQL_STMT *stmt = static_cast<MYSQL_STMT*>(js_stmt->Value());
MysqlStatement *my_stmt = new MysqlStatement(stmt);
my_stmt->Wrap(args.This());
return args.This();
}
|
Prepare statement by given query
param: String query return: Boolean
|
Handle<Value> MysqlStatement::PrepareSync(const Arguments& args) {
HandleScope scope;
MysqlStatement *stmt = OBJUNWRAP<MysqlStatement>(args.This());
REQ_STR_ARG(0, query)
int query_len = args[0]->ToString()->Utf8Length();
if (mysql_stmt_prepare(stmt->_stmt, *query, query_len)) {
return scope.Close(False());
}
return scope.Close(True());
}
|