iframe-proxy | Sunbelt Computer Software

194 lines (138 loc) · 6.49 KB
//---------------------------------------------------------------------------------------------------------------------------------
// File: Connection.cpp
// Contents: C++ interface to Microsoft Driver for Node.js for SQL Server
// Copyright Microsoft Corporation and contributors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at:
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//---------------------------------------------------------------------------------------------------------------------------------
#include "stdafx.h"
#include "Connection.h"
namespace mssql
    using namespace v8;
    Persistent<FunctionTemplate> Connection::constructor_template;
    void Connection::Initialize(Handle<Object> target)
        HandleScope scope;
        bool initialized = OdbcConnection::InitializeEnvironment();
        if( !initialized ) {
            target->Set( String::NewSymbol("Connection"), Undefined() );
            v8::ThrowException(v8::Exception::Error(v8::String::New("Unable to initialize msnodesql")));
            return;
        Local<FunctionTemplate> t = FunctionTemplate::New(Connection::New);
        constructor_template = Persistent<FunctionTemplate>::New(t);
        constructor_template->InstanceTemplate()->SetInternalFieldCount(1);
        constructor_template->SetClassName(String::NewSymbol("Connection"));
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "close", Connection::Close);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "open", Connection::Open);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "query", Connection::Query);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "readRow", Connection::ReadRow);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "readColumn", Connection::ReadColumn);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "readRowCount", Connection::ReadRowCount);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "beginTransaction", Connection::BeginTransaction);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "commit", Connection::Commit);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "rollback", Connection::Rollback);
        NODE_SET_PROTOTYPE_METHOD(constructor_template, "nextResult", Connection::ReadNextResult);
        target->Set(String::NewSymbol("Connection"), constructor_template->GetFunction());
    Connection::~Connection( void )
        // close the connection now since the object is being collected
        innerConnection->Collect();
    Handle<Value> Connection::Close(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->Close( callback ));
    Handle<Value> Connection::BeginTransaction(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->BeginTransaction( callback ));
    Handle<Value> Connection::Commit(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->Commit( callback ));
    Handle<Value> Connection::Rollback(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->Rollback( callback ));
    Handle<Value> Connection::New(const Arguments& args) 
        HandleScope scope;
        if (!args.IsConstructCall()) {
            return Undefined();
        Connection *c = new Connection();
        c->Wrap(args.This());
        return args.This();
    Handle<Value> Connection::Query(const Arguments& args)
        HandleScope scope;
        Local<String> query = args[0].As<String>();
        Local<Array> params = args[1].As<Array>();
        Local<Object> callback = args[2].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->Query(query, params, callback));
    Handle<Value> Connection::ReadRow(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->ReadRow(callback));
    Handle<Value> Connection::ReadColumn(const Arguments& args)
        HandleScope scope;
        Local<Number> column = args[0].As<Number>();
        Local<Object> callback = args[1].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->ReadColumn(column, callback));
    Handle<Value> Connection::ReadNextResult(const Arguments& args)
        HandleScope scope;
        Local<Object> callback = args[0].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->ReadNextResult(callback));
    Handle<Value> Connection::ReadRowCount(const Arguments& args)
        Connection* connection = Unwrap<Connection>(args.This());
        return connection->innerConnection->ReadRowCount();
    Handle<Value> Connection::Open(const Arguments& args)
        HandleScope scope;
        Local<String> connectionString = args[0].As<String>();
        Local<Object> callback = args[1].As<Object>();
        Connection* connection = Unwrap<Connection>(args.This());
        return scope.Close<Value>(connection->innerConnection->Open(connectionString, callback, args.This()));
NODE_MODULE(sqlserver, mssql::Connection::Initialize);
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Sunbelt Computer Software

PL/B Language Development and Support

FilesExpand file tree

Connection.cpp

Latest commit

History

Connection.cpp

File metadata and controls
