odbc.obs

use Collection;
use System.API;

#~
Database access support via ODBC (-lib odbc)
~#
bundle Database.ODBC {
	class Proxy {
		@lib_proxy : static : DllProxy;
		
		function : GetDllProxy() ~ DllProxy {
			if(@lib_proxy = Nil) {
				@lib_proxy := DllProxy->New("libobjk_odbc");
			};

			return @lib_proxy;
		}
	}
	
	#~
	ODBC database connection
	~#
	class Connection {
		@native_connection : Int;
		
		#~
		Constructor 
		@param ds ODBC data source
		@param username ODBC connection name
		@param password ODBC connection password
		~#
		New(ds : String, username : String, password : String) {
			Parent();
			array_args := Base->New[4];
			array_args[0] := IntRef->New();
			array_args[1] := ds;
			array_args[2] := username;
			array_args[3] := password;
			@lib_proxy := Proxy->GetDllProxy();
			@lib_proxy->CallFunction("odbc_connect", array_args);
			
			value := array_args[0]->As(IntRef);
			@native_connection := value->Get();
		}
      	
		#~
		Check rather a connect is open
		@return true if connected, false otherwise
		~#
		method : public : IsOpen() ~ Bool {
			return @native_connection <> 0;
		}
		
		#~
		Closes a connection
		~#
		method : public : Close() ~ Nil {
			if(@native_connection <> 0) {
				array_args := Base->New[1];
				array_args[0] := IntRef->New(@native_connection);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_disconnect", array_args);
				@native_connection := 0;
			};
		}
		
		#~
		Executes a SQL update statement
		@param sql SQL statement
		@return result code
		~#
		method : public : Update(sql : String) ~ Int {
			if(@native_connection <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(@native_connection);
				array_args[2] := sql;
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_update_statement", array_args);
				
				value := array_args[0]->As(IntRef);
				return value->Get();
			};
			
			return -1;
		}
		
		#~
		Executes a SQL select statement
		@param sql SQL statement
		@return result set
		~#
		method : public : Select(sql : String) ~ ResultSet {
			if(@native_connection <> 0) {
				array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New();
				array_args[3] := IntRef->New(@native_connection);
				array_args[4] := sql;
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_select_statement", array_args);
				
				native_stmt := array_args[0]->As(IntRef);
				native_names := array_args[1]->As(IntRef);
				exec_data := array_args[2]->As(IntRef);
				return ResultSet->New(native_stmt->Get(), native_names->Get(), exec_data->Get());
			};
			
			return Nil;
		}
		
		#~
		Create a parametrized SQL statement 
		@param sql SQL statement
		@return result set
		~#
		method : public : CreateParameterStatement(sql : String) ~ ParameterStatement {
			if(@native_connection <> 0) {
				array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New();
				array_args[3] := IntRef->New(@native_connection);
				array_args[4] := sql;
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_pepare_statement", array_args);
				
				native_stmt := array_args[0]->As(IntRef);
				native_names := array_args[1]->As(IntRef);
				exec_data := array_args[2]->As(IntRef);
				return ParameterStatement->New(native_stmt->Get(), native_names->Get(), exec_data->Get());
			};
			
			return Nil;
		}
	}
	
	#~
	ODBC parametrized statement that supports SQL variables
	~#
	class ParameterStatement {
		@native_stmt : Int;
		@native_names : Int;
		@exec_data : Int;
		@params : Vector<Base>;
		
		New(native_stmt : Int, native_names : Int, exec_data : Int) {
			@native_stmt := native_stmt;
			@native_names := native_names;
			@exec_data := exec_data;
			@params := Vector->New()<Base>;
		}
		
		#~
		Sets a bit type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetBit(pos : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_bit_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a bit type
		@param pos parameter position
		@param value bit value
		@return true if set, false otherwise
		~#
		method : public : SetBit(pos : Int, value : Bool) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := IntRef->New(value ? 1 : 0);
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_bit", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a small integer type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetSmallInt(pos : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_smallint_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a small integer type
		@param pos parameter position
		@param value small integer value
		@return true if set, false otherwise
		~#
		method : public : SetSmallInt(pos : Int, value : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := IntRef->New(value);
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_smallint", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a integer type to NULL
		@param pos parameter position
		@param value integer value
		@return true if set, false otherwise
		~#
		method : public : SetInt(pos : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_int_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a integer type
		@param pos parameter position
		@param value integer value to set
		@return true if set, false otherwise
		~#
		method : public : SetInt(pos : Int, value : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := IntRef->New(value);
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_int", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a double type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetDouble(pos : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_double_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a double type
		@param pos parameter position
		@param value double value
		@return true if set, false otherwise
		~#
		method : public : SetDouble(pos : Int, value : Float) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := FloatRef->New(value);
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_double", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a real type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetReal(pos : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_real_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a real type
		@param pos parameter position
		@param value real value
		@return true if set, false otherwise
		~#
		method : public : SetReal(pos : Int, value : Float) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := FloatRef->New(value);
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_real", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets varchar type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetVarchar(pos : Int) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_varchar_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets varchar type
		@param pos parameter position
		@param value string value
		@return true if set, false otherwise
		~#
		method : public : SetVarchar(pos : Int, value : String) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := ByteArrayRef->New(value->ToByteArray());
				@params->AddBack(input);
				
				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_varchar", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a blob type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetBlob(pos : Int) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_blob_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a blob type
		@param pos parameter position
		@param buffer byte buffer
		@return true if set, false otherwise
		~#
		method : public : SetBlob(pos : Int, buffer : Byte[]) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				input := ByteArrayRef->New(buffer);
				@params->AddBack(input);
				
				array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@exec_data);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_blob", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		method : public : SetBytes(pos : Int, buffer : Byte[]) ~ Bool {			
			return SetBytes(pos, buffer, buffer->Size());
		}
		
		#~
		Sets a stream of bytes
		@param pos parameter position
		@param buffer byte buffer
		@param length number of bytes to write
		@return true if set, false otherwise
		~#
		method : public : SetBytes(pos : Int, buffer : Byte[], length : Int) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				if(length > buffer->Size()) {
					length := buffer->Size();
				};

				input := ByteArrayRef->New(buffer);
				@params->AddBack(input);
				
				array_args := Base->New[6];
				array_args[0] := IntRef->New();
				array_args[1] := input;
				array_args[2] := IntRef->New(length);
				array_args[3] := IntRef->New(pos);
				array_args[4] := IntRef->New(@native_stmt);
				array_args[5] := IntRef->New(@exec_data);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_bytes", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a date type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetDate(pos : Int) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_date_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a date type
		@param pos parameter position
		@param value date value
		@return true if set, false otherwise
		~#
		method : public : SetDate(pos : Int, value : Date) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				@params->AddBack(value);

				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := value;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_date", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Sets a timestamp type to NULL
		@param pos parameter position
		@return true if set, false otherwise
		~#
		method : public : SetTimestamp(pos : Int) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[3];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(pos);
				array_args[2] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_timestamp_null", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}

		#~
		Sets a timestamp type
		@param pos parameter position
		@param value timestamp value
		@return true if set, false otherwise
		~#
		method : public : SetTimestamp(pos : Int, value : Timestamp) ~ Bool {		
			if(@native_stmt <> 0 & @native_names <> 0) {
				@params->AddBack(value);

				array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := value;
				array_args[2] := IntRef->New(pos);
				array_args[3] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_set_timestamp", array_args);
				
				status := array_args[0]->As(IntRef);
				return status->Get() = 1;
			};
			
			return false;
		}
		
		#~
		Executes a SQL update statement. Statement is closed after calling.
		@param sql SQL statement
		@return result code
		~#
		method : public : Update() ~ Int {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[4];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(@native_stmt);
				array_args[2] := IntRef->New(@exec_data);
				array_args[3] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_update", array_args);
				@params->Empty();

				value := array_args[0]->As(IntRef);
				status := value->Get();
				if(status < 0) {
					@native_stmt := 0;
					@exec_data := 0;
					@native_names := 0;
				};
				return status;
      		};
      		
      		return -1;
		}
		
		#~
		Executes a SQL select statement
		@param sql SQL statement
		@return result set
		~#
		method : public : Select() ~ ResultSet {
			if(@native_stmt <> 0 & @native_names <> 0) {
				array_args := Base->New[1];
				array_args[0] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_select_statement", array_args);
				@params->Empty();
				
				return ResultSet->New(@native_stmt, @native_names, @exec_data);
			};
			
			return Nil;
		}
		
		#~
		Closes the statement
		~#
		method : public : Close() ~ Nil {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[1];
				array_args[0] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_stmt_close", array_args);
				@params->Empty();
				@native_stmt := 0;
      		};
      	}
	}
	
	#~
	ODBC result set
	~#
	class ResultSet {
		@native_stmt : Int;
		@native_names : Int;
		@exec_data : Int;
		@is_null : Bool;

		New(native_stmt : Int, native_names : Int, exec_data : Int) {
			@native_stmt := native_stmt;
			@native_names := native_names;
			@exec_data := exec_data;
		}
		

		#~
		Get the metadata for a given column
		@param column column name
		@return column metadata
		~#
		method : public : GetColumnInfo() ~ ColumnInfo[] {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[2];

				array_args[0] := Nil;
				array_args[1] := IntRef->New(@native_stmt);

				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_metadata", array_args);
				
				value := array_args[0]->As(ColumnInfoRef);
				return value->Get();
      		};
      		
      		return Nil;
		}

		#~
		Moves the cursor to the next row in the result set
		@return true if cursor was moved, false otherwise
		~#
		method : public : Next() ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[2];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New(@native_stmt);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_next", array_args);
				
				value := array_args[0]->As(IntRef);
				return value->Get() = 1;
      		};
      		
      		return false;
		}
				
		#~
		Checks to see if the value fetched is NUL. This method should be called
		after a value is fetched using GetX(column).
		@return true if NIL, false otherwise
		~#
		method : public : IsNull() ~ Bool {
			return @is_null;
		}
		
		#~
		Gets an integer value
		@param column column ID
		@return integer value
		~#
		method : public : GetInt(column : Int) ~ Int {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_int_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get();
      		};
      		
      		return 0;
		}

		#~
		Gets an integer value
		@param column column name
		@return integer value
		~#
		method : public : GetInt(column : String) ~ Int {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_int_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get();
      		};
      		
      		return 0;
		}
		
		#~
		Gets a small integer value
		@param column column ID
		@return small integer value
		~#
		method : public : GetSmallInt(column : Int) ~ Int {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_smallint_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get();
      		};
      		
      		return 0;
		}

		#~
		Gets a small integer value
		@param column column name
		@return small integer value
		~#
		method : public : GetSmallInt(column : String) ~ Int {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_smallint_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get();
      		};
      		
      		return 0;
		}
		
		#~
		Gets a bit value
		@param column column ID
		@return bit value
		~#
		method : public : GetBit(column : Int) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_bit_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get() = 1;
      		};
      		
      		return false;
		}

		#~
		Gets a bit value
		@param column column name
		@return bit value
		~#
		method : public : GetBit(column : String) ~ Bool {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_bit_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(IntRef);
				return value->Get() = 1;
      		};
      		
      		return false;
		}
		
		#~
		Gets a double value
		@param column column ID
		@return double value
		~#
		method : public : GetDouble(column : Int) ~ Float {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := FloatRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_double_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(FloatRef);
				return value->Get();
      		};
      		
      		return 0.0;
		}

		#~
		Gets a double value
		@param column column name
		@return double value
		~#
		method : public : GetDouble(column : String) ~ Float {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := FloatRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_double_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(FloatRef);
				return value->Get();
      		};
      		
      		return 0.0;
		}
		
		#~
		Gets a real value
		@param column column ID
		@return real value
		~#
		method : public : GetReal(column : Int) ~ Float {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := FloatRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_real_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(FloatRef);
				return value->Get();
      		};
      		
      		return 0.0;
		}

		#~
		Gets a real value
		@param column column name
		@return real value
		~#
		method : public : GetReal(column : String) ~ Float {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := FloatRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_real_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				value := array_args[1]->As(FloatRef);
				return value->Get();
      		};
      		
      		return 0.0;
		}
		
		#~
		Gets a varchar value
		@param column column ID
		@return varchar value
		~#
		method : public : GetVarchar(column : Int) ~ String {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_varchar_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(String);
      		};
      		
      		return Nil;
		}

		#~
		Gets a varchar value
		@param column column name
		@return varchar value
		~#
		method : public : GetVarchar(column : String) ~ String {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_varchar_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(String);
      		};
      		
      		return Nil;
		}

		#~
		Gets a blob value
		@param column column ID
		@param buffer buffer to write into
		~#
		method : public : GetBlob(column : Int, buffer : Byte[]) ~ Nil {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := ByteArrayRef->New(buffer);
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_blob_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
      		};
		}

		#~
		Gets a blob value
		@param column column name
		@param buffer buffer to write into
		~#
		method : public : GetBlob(column : String, buffer : Byte[]) ~ Nil {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := ByteArrayRef->New(buffer);
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_blob_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
      		};
		}
		
		#~
		Gets a date value
		@param column column ID
		@return date value
		~#
		method : public : GetDate(column : Int) ~ Database.ODBC.Date {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_date_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(Database.ODBC.Date);
      		};
      		
      		return Nil;
		}

		#~
		Gets a date value
		@param column column name
		@return date value
		~#
		method : public : GetDate(column : String) ~ Database.ODBC.Date {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_date_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(Database.ODBC.Date);
      		};
      		
      		return Nil;
		}
		
		#~
		Gets a timestamp value
		@param column column ID
		@return timestamp value
		~#
		method : public : GetTimestamp(column : Int) ~ Timestamp {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := IntRef->New(column);
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_timestamp_by_id", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(Timestamp);
      		};
      		
      		return Nil;
		}

		#~
		Gets a timestamp value
		@param column column name
		@return timestamp value
		~#
		method : public : GetTimestamp(column : String) ~ Timestamp {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[5];
				array_args[0] := IntRef->New();
				array_args[1] := IntRef->New();
				array_args[2] := column;
				array_args[3] := IntRef->New(@native_stmt);
				array_args[4] := IntRef->New(@native_names);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_get_timestamp_by_name", array_args);
				
				is_null := array_args[0]->As(IntRef);
				@is_null := is_null->Get() = 1;
				
				if(@is_null) {
					return Nil;
				};
				return array_args[1]->As(Timestamp);
      		};
      		
      		return Nil;
		}
		
		#~
		Closes a result set 
		~#
		method : public : Close() ~ Nil {
			if(@native_stmt <> 0 & @native_names <> 0) {
      			array_args := Base->New[2];
				array_args[0] := IntRef->New(@native_names);
				array_args[1] := IntRef->New(@exec_data);
				@lib_proxy := Proxy->GetDllProxy();
				@lib_proxy->CallFunction("odbc_result_close", array_args);
				@native_names := 0;
				@exec_data := 0;
	      		};
	      	}
	}
	
	class : private : ColumnInfoRef {
		@column_info : ColumnInfo[];

		New() {
		}

		method : public : Get() ~ ColumnInfo[] {
			return @column_info;
		}
	}

	#~
	Result set column metadata
	~#
	class ColumnInfo {
		@type : ColumnInfo->Type;
		@name : String;
		@size : Int;
		@decimal_digits : Int;
		@nullable : Bool;

		New() {}

		#~
		Column type
		@class ColumnInfo
		~#
		consts Type {
			SQL_UNKNOWN_TYPE := 0,
			SQL_CHAR := 1,
			SQL_NUMERIC := 2,
			SQL_DECIMAL := 3,
			SQL_INTEGER := 4,
			SQL_SMALLINT := 5,
			SQL_FLOAT := 6,
			SQL_REAL := 7,
			SQL_DOUBLE := 8,
			SQL_DATETIME := 9,
			SQL_VARCHAR := 12,
			SQL_TYPE_DATE := 91,
			SQL_TYPE_TIME := 92,
			SQL_TYPE_TIMESTAMP := 93
		}

		#~
		Get column type
		@return column type
		~#
		method : public : GetType() ~ ColumnInfo->Type {
			return @type;
		}

		#~
		Get column name
		@return column name
		~#
		method : public : GetName() ~ String {
			return @name;
		}

		#~
		Get column size
		@return column size
		~#
		method : public : GetSize() ~ Int {
			return @size;
		}

		#~
		Get column decimal digits 
		@return decimal digits
		~#
		method : public : GetDecimalDigits() ~ Int {
			return @decimal_digits;
		}

		#~
		Determine if column is nullable
		@return if column is nullable, false otherwise
		~#
		method : public : IsNullable() ~ Bool {
			return @nullable;
		}

		#~
		String representation of column metadata
		@return string representation of column metadata
		~#
		method : public : ToString() ~ String {
			buffer := "";

			select(@type) {
				label ColumnInfo->Type->SQL_UNKNOWN_TYPE {
					buffer += "SQL_UNKNOWN_TYPE";
				}

				label ColumnInfo->Type->SQL_CHAR {
					buffer += "SQL_CHAR";
				}

				label ColumnInfo->Type->SQL_NUMERIC {
					buffer += "SQL_NUMERIC";
				}

				label ColumnInfo->Type->SQL_DECIMAL {
					buffer += "SQL_DECIMAL";
				}

				label ColumnInfo->Type->SQL_INTEGER {
					buffer += "SQL_INTEGER";
				}

				label ColumnInfo->Type->SQL_SMALLINT {
					buffer += "SQL_SMALLINT";
				}

				label ColumnInfo->Type->SQL_FLOAT {
					buffer += "SQL_FLOAT";
				}

				label ColumnInfo->Type->SQL_REAL {
					buffer += "SQL_REAL";
				}

				label ColumnInfo->Type->SQL_DOUBLE {
					buffer += "SQL_DOUBLE";
				}

				label ColumnInfo->Type->SQL_DATETIME {
					buffer += "SQL_DATETIME";
				}

				label ColumnInfo->Type->SQL_VARCHAR {
					buffer += "SQL_VARCHAR";
				}

				label ColumnInfo->Type->SQL_TYPE_DATE {
					buffer += "SQL_TYPE_DATE";
				}

				label ColumnInfo->Type->SQL_TYPE_TIME {
					buffer += "SQL_TYPE_TIME";
				}

				label ColumnInfo->Type->SQL_TYPE_TIMESTAMP {
					buffer += "SQL_TYPE_TIMESTAMP";
				}

				other {
					buffer += ">> OTHER <<";
				}
			}

			buffer += ", '{$@name}', {$@size}, {$@decimal_digits}, {$@nullable}";

			return buffer;
		}
	}

	#~
	ODBC date
	~#
	class Date {
		@buffer : Byte[];
		@year : Int;
		@month : Int;
		@day : Int;
		
		#~
		Default constructor
		~#
		New() {
			# size of c struct
			@buffer := Byte->New[6];
		}
		
		#~
		Copy constructor for System.Time.Date
		@param date System.Time.Date
		~#
		New(date : System.Time.Date) {
			# size of c struct
			@buffer := Byte->New[6];
			
			@year := date->GetYear();
			@month := date->GetMonth();
			@day := date->GetDay();
		}
		
		#~
		Gets the year
		@return year
		~#
		method : public : GetYear() ~ Int {
			return @year;
		}

		#~
		Sets the year
		@param year value
		~#
		method : public : SetYear(year : Int) ~ Nil {
			@year := year;
		}
		
		#~
		Gets the month
		@return month
		~#
		method : public : GetMonth() ~ Int {
			return @month;
		}

		#~
		Sets the month
		@param month value
		~#
		method : public : SetMonth(month : Int) ~ Nil {
			@month := month;
		}
		
		#~
		Gets the day
		@return day
		~#
		method : public : GetDay() ~ Int {
			return @day;
		}
		
		#~
		Sets the day
		@param day value
		~#
		method : public : SetDay(day : Int) ~ Nil {
			@day := day;
		}

		#~
		Converts a ODBC date into a system date
		@return system date
		~#
		method : public : ToDate() ~ System.Time.Date {
			return System.Time.Date->New(@day, @month, @year, false);
		}
		
		#~
		Creates a string representation of the date
		@return string representation of the date
		~#
		method : public : ToString() ~ String {
			out := String->New();

			out->Append(@month);
			out->Append('/');
			out->Append(@day);
			out->Append('/');
			out->Append(@year);

			return out;
		}
	}
	
	#~
	ODBC Timestamp holder
	~#
	class Timestamp {
		@buffer : Byte[];
		@year : Int;
		@month : Int;
		@day : Int;
		@hours : Int;
		@minute : Int;
		@second : Int;
		@fraction : Int;
		
		#~
		Default constructor
		~#
		New() {
			# size of c struct
			@buffer := Byte->New[16];
		}
		
		#~
		Copy constructor for System.Time.Date
		@param date System.Time.Date
		~#
		New(date : System.Time.Date) {
			# size of c struct
			@buffer := Byte->New[16];
			
			@year := date->GetYear();
			@month := date->GetMonth();
			@day := date->GetDay();
			@hours := date->GetHours();
			@minute := date->GetMinutes();
			@second := date->GetSeconds();
		}
		
		#~
		Gets the year
		@return year
		~#
		method : public : GetYear() ~ Int {
			return @year;
		}

		#~
		Sets the year
		@param year value
		~#
		method : public : SetYear(year : Int) ~ Nil {
			@year := year;
		}
		
		#~
		Gets the month
		@return month
		~#
		method : public : GetMonth() ~ Int {
			return @month;
		}

		#~
		Sets the month
		@param month value
		~#
		method : public : SetMonth(month : Int) ~ Nil {
			@month := month;
		}
		
		#~
		Gets the day
		@return day
		~#
		method : public : GetDay() ~ Int {
			return @day;
		}
		
		#~
		Sets the day
		@param day value
		~#
		method : public : SetDay(day : Int) ~ Nil {
			@day := day;
		}

		#~
		Gets the hours
		@return hours
		~#
		method : public : GetHours() ~ Int {
			return @hours;
		}
		
		#~
		Sets the hours
		@param hours hours
		~#
		method : public : SetHours(hours : Int) ~ Nil {
			@hours := hours;
		}

		#~
		Gets the minutes
		@return minutes
		~#
		method : public : GetMinutes() ~ Int {
			return @minute;
		}
		
		#~
		Sets the minutes
		@param minute minutes
		~#
		method : public : SetMinutes(minute : Int) ~ Nil {
			@minute := minute;
		}

		#~
		Gets the seconds
		@return seconds
		~#
		method : public : GetSeconds() ~ Int {
			return @second;
		}
		
		#~
		Sets the seconds
		@param second seconds
		~#
		method : public : SetSeconds(second : Int) ~ Nil {
			@second := second;
		}

		#~
		Gets the fraction of seconds
		@return fraction of seconds
		~#
		method : public : GetFraction() ~ Int {
			return @fraction;
		}

		#~
		Converts a timestamp into a system date
		@return system date
		~#
		method : public : ToDate() ~ System.Time.Date {
			date := System.Time.Date->New(@day, @month, @year, false);
			date->AddHours(@hours);
			date->AddMinutes(@minute);
			date->AddSeconds(@second);
			
			return date;
		}
		
		#~
		Creates a string representation of the timestamp
		@return string representation of the timestamp
		~#
		method : public : ToString() ~ String {
			out := String->New();

			out->Append(@month);
			out->Append('/');
			out->Append(@day);
			out->Append('/');
			out->Append(@year);
			out->Append(" ");

			is_am := true;
			if(@hours = 0) {
				out->Append(12);
			}
			else if(@hours = 12) {
				out->Append(12);
				is_am := false;
			}
			else if(@hours > 12) {
				out->Append(@hours - 12);
				is_am := false;
			}
			else {
				out->Append(@hours);
			};

			out->Append(":");
			if(@minute < 10) {
				out->Append('0');
			};
			out->Append(@minute);

			out->Append(":");
			if(@second < 10) {
				out->Append('0');
			};
			out->Append(@second);

			if(is_am) {
				out->Append(" AM");
			}
			else {
				out->Append(" PM");
			};

			return out;
		}
	}
}