mssqlclient 0.1.0

data/src/AssemblyInfo.cpp

@@ -0,0 +1,38 @@
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute("MsSqlAdapter")];
+[assembly:AssemblyDescriptionAttribute("")];
+[assembly:AssemblyConfigurationAttribute("")];
+[assembly:AssemblyCompanyAttribute("")];
+[assembly:AssemblyProductAttribute("MsSqlAdapter")];
+[assembly:AssemblyCopyrightAttribute("Copyright (c)  2006")];
+[assembly:AssemblyTrademarkAttribute("")];
+[assembly:AssemblyCultureAttribute("")];
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the value or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly:AssemblyVersionAttribute("1.0.*")];
+
+[assembly:ComVisible(false)];
+
+[assembly:CLSCompliantAttribute(true)];
+
+[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];

data/src/Helpers.cpp

@@ -0,0 +1,177 @@
+#include "helpers.h"
+
+VALUE g_CBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+VALUE g_CDate = rb_const_get(rb_cObject, rb_intern("Date"));
+VALUE g_CTime = rb_const_get(rb_cObject, rb_intern("Time"));
+VALUE g_CDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+
+namespace MsSqlClient {
+	namespace Helpers {
+		VALUE CastToRubyObject(Type^ clr_type, Object^ object) {			
+			VALUE ruby_value = Qnil;
+
+			if (object == System::DBNull::Value) {
+				ruby_value = Qnil;
+			} else if (clr_type == System::DateTime::typeid) {
+				return rb_funcall(g_CDate, rb_intern("new"), 3, ToRubyNumber(2006), ToRubyNumber(9), ToRubyNumber(7));
+
+				gcroot<DateTime^> clr_date_time = (DateTime^)object;
+				if (clr_date_time->Hour == 0 && clr_date_time->Minute == 0 && clr_date_time->Second == 0) {							
+					// Create a Ruby Date Object
+					ruby_value = rb_funcall(g_CDate, rb_intern("new"), 3, 
+						ToRubyNumber(clr_date_time->Year), 
+						ToRubyNumber(clr_date_time->Month), 
+						ToRubyNumber(clr_date_time->Day)
+						);
+				} else {							
+					// Create a Ruby DateTime Object
+					ruby_value = rb_funcall(g_CTime, rb_intern("local"), 3, 
+						ToRubyNumber(clr_date_time->Year), 
+						ToRubyNumber(clr_date_time->Month), 
+						ToRubyNumber(clr_date_time->Day),
+						ToRubyNumber(clr_date_time->Hour), 
+						ToRubyNumber(clr_date_time->Minute), 
+						ToRubyNumber(clr_date_time->Second)
+						);
+				}
+			} else {
+				if (clr_type == Boolean::typeid) ruby_value = Helpers::ToRubyBoolean((Boolean)object);
+				if (clr_type == SByte::typeid)   ruby_value = Helpers::ToRubyNumber((SByte)object);
+				if (clr_type == Int16::typeid)   ruby_value = Helpers::ToRubyNumber((Int16)object);
+				if (clr_type == Int32::typeid)   ruby_value = Helpers::ToRubyNumber((Int32)object);
+				if (clr_type == Int64::typeid)   ruby_value = Helpers::ToRubyNumber((Int64)object);
+				if (clr_type == Byte::typeid)    ruby_value = Helpers::ToRubyNumber((Byte)object);
+				if (clr_type == UInt16::typeid)  ruby_value = Helpers::ToRubyNumber((UInt16)object);
+				if (clr_type == UInt32::typeid)  ruby_value = Helpers::ToRubyNumber((UInt32)object);
+				if (clr_type == UInt64::typeid)  ruby_value = Helpers::ToRubyNumber((UInt64)object);
+				if (clr_type == String::typeid)  ruby_value = Helpers::ToRubyString((String^)object);
+				if (clr_type == Single::typeid)  ruby_value = Helpers::ToRubyNumber((Single)object);
+				if (clr_type == Double::typeid)  ruby_value = Helpers::ToRubyNumber((Double)object);
+			}
+
+			return ruby_value;
+		}
+
+		VALUE convert_reader_to_rowset(SqlDataReader^ reader) {		
+			VALUE rows = rb_ary_new();			
+
+			array<Type^> ^field_types = gcnew array<Type^>(reader->FieldCount);
+			array<String^> ^field_names = gcnew array<String^>(reader->FieldCount);
+			
+			for (int ordinal = 0; ordinal < field_types->Length; ordinal++) {
+				field_names[ordinal] = reader->GetName(ordinal);
+				field_types[ordinal] = reader->GetFieldType(ordinal);								
+			}
+
+			while (reader->Read()) {
+				VALUE record = rb_hash_new();			
+				for (int ordinal = 0; ordinal < field_types->Length; ordinal++) {
+					gcroot<Object^> object = reader->GetValue(ordinal);
+					rb_hash_aset(record, ToRubyString(field_names[ordinal]), CastToRubyObject((Type^)field_types[ordinal], object));
+					delete object;
+				}
+
+				rb_ary_push(rows, record);
+			}
+
+			delete field_names;
+			delete field_types;
+
+			return rows;
+		}
+
+		VALUE ToRubyObject(Object^ object) {
+			Type^ objectType = object->GetType();
+			VALUE ruby_value = Qnil;
+
+			if (System::DBNull::Value == object) {
+				ruby_value = Qnil;
+			} else if (object->GetType() == System::Decimal::typeid) {				
+				ruby_value = rb_float_new(Convert::ToDouble(object));
+			} else if (object->GetType() == System::DateTime::typeid) {				
+				char* native_string;
+				ConvertToCharStar("Time.parse(\"" + object->ToString() + "\")", native_string);
+				return rb_eval_string(native_string);				
+			} else {
+				if (objectType == Boolean::typeid) return Helpers::ToRubyBoolean((Boolean)object);
+				if (objectType == SByte::typeid)   return Helpers::ToRubyNumber((SByte)object);
+				if (objectType == Int16::typeid)   return Helpers::ToRubyNumber((Int16)object);
+				if (objectType == Int32::typeid)   return Helpers::ToRubyNumber((Int32)object);
+				if (objectType == Int64::typeid)   return Helpers::ToRubyNumber((Int64)object);
+				if (objectType == Byte::typeid)    return Helpers::ToRubyNumber((Byte)object);
+				if (objectType == UInt16::typeid)  return Helpers::ToRubyNumber((UInt16)object);
+				if (objectType == UInt32::typeid)  return Helpers::ToRubyNumber((UInt32)object);
+				if (objectType == UInt64::typeid)  return Helpers::ToRubyNumber((UInt64)object);
+				if (objectType == String::typeid)  return Helpers::ToRubyString((String^)object);
+				if (objectType == Single::typeid)  return Helpers::ToRubyNumber((Single)object);
+				if (objectType == Double::typeid)  return Helpers::ToRubyNumber((Double)object);
+			}
+
+			return ruby_value;
+		}
+
+		VALUE ToRubyNumber(Int64 value)   { return rb_ll2inum(value); }
+		VALUE ToRubyNumber(Int32 value)   { return rb_int2inum(value); }
+		VALUE ToRubyNumber(Int16 value)   { return rb_int2inum(value); }
+		VALUE ToRubyNumber(SByte value)   { return rb_int2inum(value); }
+		VALUE ToRubyNumber(UInt64 value)  { return rb_ull2inum(value); }
+		VALUE ToRubyNumber(UInt32 value)  { return rb_uint2inum(value); }
+		VALUE ToRubyNumber(UInt16 value)  { return rb_uint2inum(value); }
+		VALUE ToRubyNumber(Byte value)    { return rb_uint2inum(value); }
+		VALUE ToRubyNumber(Double value)  { return rb_float_new(value); }
+		VALUE ToRubyNumber(Single value)  { return rb_float_new(value); }
+
+		VALUE ToRubyNumber(Decimal value) {
+			VALUE val = ToRubyString(value.ToString());
+			return rb_funcall(g_CBigDecimal, rb_intern("new"), 1, val);
+		}
+
+		VALUE ToRubyBoolean(bool value)   { return value ? Qtrue : Qfalse; }
+		VALUE ToRubyNil()                 { return Qnil; }
+
+		String^ ToClrString(VALUE self) {
+			if (self == Qnil) return nullptr;
+			char* native_string = STR2CSTR(self);
+
+			size_t native_size = strlen(native_string);
+			array<unsigned char>^ bytes = gcnew array<unsigned char>(native_size);
+
+			for(unsigned int i = 0; i < native_size; i++) {
+				bytes[i] = System::Byte(native_string[i]);
+			}
+
+			String^ return_value = System::Text::Encoding::UTF8->GetString(bytes);
+			  
+			delete bytes;
+			
+			return return_value;
+		}
+
+		VALUE ToRubyString(String^ string) {
+			if (string == nullptr) return Qnil;
+
+			char *ptr = (char*)malloc(4+System::Text::Encoding::UTF8->GetByteCount(string));
+			cli::array<unsigned char>^ char_array = System::Text::Encoding::UTF8->GetBytes(string);
+			cli::pin_ptr<unsigned char> char_pin_ptr = &char_array[0];
+			strcpy(ptr, (char*)char_pin_ptr);
+			return rb_str_new2((char*)(void*)ptr);
+		}
+
+		bool ConvertToCharStar( String^ source, char*& target ) {
+			int len = (( source->Length+1) * 2);
+			target = new char[ len ];
+			pin_ptr<const wchar_t> wch = PtrToStringChars( source );
+			return wcstombs( target, wch, len ) != -1;
+		}
+
+		void release_object(void *objref) {
+		  if (objref != 0 && *((int*)objref) != 0) {
+			int *objectReference = (int*)objref;
+			GCHandle handle = (GCHandle)(IntPtr)*objectReference;
+			//Identity::RemoveProxyObject(handle.Target);
+			handle.Free();
+			xfree(objectReference);
+		  }
+		}
+	}
+}

data/src/Helpers.h

@@ -0,0 +1,44 @@
+#include <windows.h>
+#include <vcclr.h>
+#include <ruby.h>
+
+#define _CRT_SECURE_NO_DEPRECATE 1
+#pragma warning(disable:4947)
+
+using namespace System;
+using namespace System::Data;
+using namespace System::Data::SqlClient;
+using namespace System::Runtime;
+using namespace System::Runtime::InteropServices;
+
+namespace MsSqlClient {
+	namespace Helpers {		
+		
+		VALUE CastToRubyObject(Type^ clr_type, Object^ object);
+		VALUE convert_reader_to_rowset(SqlDataReader^ reader);
+
+		// Marshaling Methods
+		VALUE ToRubyString(String^ string);
+		VALUE ToRubyObject(Object^ object);
+		VALUE ToRubyNumber(Int64 value);
+		VALUE ToRubyNumber(Int32 value);
+		VALUE ToRubyNumber(Int16 value);
+		VALUE ToRubyNumber(SByte value);
+		VALUE ToRubyNumber(UInt64 value);
+		VALUE ToRubyNumber(UInt32 value);
+		VALUE ToRubyNumber(UInt16 value);
+		VALUE ToRubyNumber(Byte value);
+		VALUE ToRubyNumber(Double value);
+		VALUE ToRubyNumber(Single value);
+		VALUE ToRubyNumber(Decimal value);
+		VALUE ToRubyBoolean(bool value);
+		VALUE ToRubyNil();
+		String^ ToClrString(VALUE string);
+		VALUE ToRubyString(String^ string);
+
+		bool ConvertToCharStar( String^ source, char*& target );
+
+		// Garbage Collection
+		void release_object(void *objref);
+	}
+}

data/src/MsSqlClient..express.sln

@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ms_sql_client", "MsSqlClient.express.vcproj", "{358B7FEF-C413-48BA-B3C6-134BCC270245}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{358B7FEF-C413-48BA-B3C6-134BCC270245}.Debug|Win32.ActiveCfg = Debug|Win32
+		{358B7FEF-C413-48BA-B3C6-134BCC270245}.Debug|Win32.Build.0 = Debug|Win32
+		{358B7FEF-C413-48BA-B3C6-134BCC270245}.Release|Win32.ActiveCfg = Release|Win32
+		{358B7FEF-C413-48BA-B3C6-134BCC270245}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/src/MsSqlClient.cpp

@@ -0,0 +1,196 @@
+#include "mssqlclient.h"
+
+namespace MsSqlClient {
+
+	VALUE e_ActiveRecordStatementInvalid = rb_eval_string("ActiveRecord::StatementInvalid");
+
+	gcroot<SqlTransaction^> transaction;
+
+	// MsSqlAdapter Helper Methods
+
+	bool in_transaction(VALUE instance) {
+		return rb_iv_get(instance, "@in_transaction") == Qtrue;;
+	}
+
+	gcroot<SqlConnection^> get_connection(VALUE instance) {
+		if (in_transaction(instance)) {
+			return transaction->Connection;
+		} else {
+			gcroot<SqlConnection^> connection = gcnew SqlConnection();
+			connection->ConnectionString = Helpers::ToClrString(rb_funcall(instance, rb_intern("connection_string"), 0));
+			connection->Open();			
+			return connection;
+		}
+	}
+
+	void destroy_connection(SqlConnection^ connection) {
+		connection->Close();
+		delete connection;
+	}
+
+	VALUE c_MsSqlAdapter_begin_db_transaction(VALUE instance) {
+		gcroot<SqlConnection^> connection = get_connection(instance);
+		transaction = connection->BeginTransaction();
+		return rb_iv_set(instance, "@in_transaction", Qtrue);
+	}
+
+	VALUE c_MsSqlAdapter_commit_db_transaction(VALUE instance) {
+		gcroot<SqlConnection^> connection = transaction->Connection;
+		transaction->Commit();
+		destroy_connection(connection);
+		delete transaction;
+		return rb_iv_set(instance, "@in_transaction", Qfalse);		
+	}
+
+	VALUE c_MsSqlAdapter_rollback_db_transaction(VALUE instance) {
+		gcroot<SqlConnection^> connection = transaction->Connection;
+		transaction->Rollback();
+		destroy_connection(connection);
+		delete transaction;
+		return rb_iv_set(instance, "@in_transaction", Qfalse);
+	}
+
+
+	// MsSqlAdapter Instance Methods
+
+	static VALUE c_MsSqlAdapter_allocate_connection(VALUE self) {
+		return Qnil;
+	}
+
+	// This method is not part of the AbstractAdapter implementation
+	static VALUE c_MsSqlAdapter_select(VALUE self, VALUE query) {
+		try {
+			gcroot<SqlConnection^> connection = get_connection(self);
+			VALUE records = rb_ary_new();
+			gcroot<String^> command_text = Helpers::ToClrString(query);
+			gcroot<SqlCommand^> command = connection->CreateCommand();
+			
+			if (in_transaction(self)) {
+				command->Transaction = transaction;
+			}
+
+			try {			
+				command->CommandText = command_text;
+				command->CommandType = CommandType::Text;
+				gcroot<SqlDataReader^> reader = command->ExecuteReader();
+
+				if (reader->HasRows) {
+					records = Helpers::convert_reader_to_rowset(reader);
+				}
+
+				reader->Close();
+				delete reader;
+			} catch (SqlException^ sqlEx) {
+				char* native_message;
+				Helpers::ConvertToCharStar(sqlEx->ToString(), native_message);
+				rb_raise(e_ActiveRecordStatementInvalid, native_message);
+				command->Cancel();
+			} finally {
+				delete command;
+				delete command_text;
+				if (!in_transaction(self)) {
+					destroy_connection(connection);
+				}
+			}
+
+			return records;
+		} catch(Exception^ e) {
+			char* native_message;
+			Helpers::ConvertToCharStar(e->ToString(), native_message);
+			rb_raise(e_ActiveRecordStatementInvalid, native_message);
+		}
+	}
+
+	static VALUE c_MsSqlAdapter_insert(VALUE self, VALUE query) {
+		gcroot<SqlConnection^> connection = get_connection(self);
+		VALUE return_value = Qnil;
+		gcroot<String^> command_text = String::Concat(Helpers::ToClrString(query), "\r\nSELECT SCOPE_IDENTITY() as NewIdentity");
+		gcroot<SqlCommand^> command;
+
+		try {
+			if (in_transaction(self)) {
+				command = transaction->Connection->CreateCommand();
+				command->Transaction = transaction;
+			} else {
+				command = connection->CreateCommand();
+			}
+
+			command->CommandText = command_text;
+			command->CommandType = CommandType::Text;
+
+			gcroot<Object^> value = command->ExecuteScalar();
+			return_value = Helpers::ToRubyObject(value);
+		} catch (SqlException^ sqlEx) {	
+			char* native_message;
+			Helpers::ConvertToCharStar(String::Format("Command Text: {0}\nError: {1}", command_text, sqlEx->ToString()), native_message);
+			rb_raise(e_ActiveRecordStatementInvalid, native_message);
+			command->Cancel();
+		} finally {
+			delete command;
+			delete command_text;
+
+			if (!in_transaction(self)) {
+				destroy_connection(connection);
+			}
+		}
+
+		return return_value;
+
+	}
+	
+	static VALUE c_MsSqlAdapter_execute(VALUE self, VALUE query) {
+		gcroot<SqlConnection^> connection = get_connection(self);
+		VALUE return_value = Qnil;
+		gcroot<String^> command_text = Helpers::ToClrString(query);
+		gcroot<SqlCommand^> command;
+
+		try {
+
+			if (in_transaction(self)) {
+				command = transaction->Connection->CreateCommand();
+				command->Transaction = transaction;
+			} else {
+				command = connection->CreateCommand();
+			}
+			
+			command->CommandText = command_text;
+			command->CommandType = CommandType::Text;
+
+			return_value = Helpers::ToRubyNumber(command->ExecuteNonQuery());
+		} catch (SqlException^ sqlEx) {	
+			char* native_message;
+			Helpers::ConvertToCharStar(String::Format("Command Text: {0}\nError: {1}", command_text, sqlEx->ToString()), native_message);
+			rb_raise(e_ActiveRecordStatementInvalid, native_message);
+			command->Cancel();
+		} finally {
+			delete command;
+			delete command_text;
+
+			if (!in_transaction(self)) {
+				destroy_connection(connection);
+			}
+		}
+
+		return return_value;
+	}
+
+	extern "C" {
+
+		#pragma unmanaged
+		// Main entry point
+		__declspec(dllexport) void Init_ms_sql_client() {
+			CoInitializeEx(0, COINIT_APARTMENTTHREADED);
+
+			rb_require("date");
+			
+			VALUE r_MsSqlAdapter_module = rb_define_module("MsSqlClient");
+			rb_define_method(r_MsSqlAdapter_module, "_select", RUBY_METHOD_FUNC(c_MsSqlAdapter_select), 1);
+			rb_define_method(r_MsSqlAdapter_module, "_insert", RUBY_METHOD_FUNC(c_MsSqlAdapter_insert), 1);
+			rb_define_method(r_MsSqlAdapter_module, "_execute", RUBY_METHOD_FUNC(c_MsSqlAdapter_execute), 1);
+			rb_define_method(r_MsSqlAdapter_module, "begin_db_transaction", RUBY_METHOD_FUNC(c_MsSqlAdapter_begin_db_transaction), 0);
+			rb_define_method(r_MsSqlAdapter_module, "commit_db_transaction", RUBY_METHOD_FUNC(c_MsSqlAdapter_commit_db_transaction), 0);
+			rb_define_method(r_MsSqlAdapter_module, "rollback_db_transaction", RUBY_METHOD_FUNC(c_MsSqlAdapter_rollback_db_transaction), 0);
+			
+		}
+	}
+}