sqlanywhere-ffi 1.0.0

data/CHANGELOG

@@ -0,0 +1,34 @@
+=CHANGE LOG
+
+=====0.1.5 -- 2010/01/25
+- Updated library to use DBCAPI 2.0
+- Changed test suite to correctly test BIT and TINYINT types
+- Added support for Ruby 1.9.1
+
+=====0.1.4 -- 2009/03/25
+- Changed Rakefile to automatically create lib directory
+- Fixed bug that tried to build native extensions on binary distsributions
+
+=====0.1.3 -- 2008/12/31
+- Removed 'hint file' in lib directory
+- Added extensions to gemspec to force a local compile
+
+=====0.1.2 -- 2008/12/18
+- Fixed bug when trying to read input value from OUTPUT parameter
+- Added error checking to C2RB
+- Fixed Rake to handle .bundle on OSX
+
+=====0.1.1 -- 2008/11/06
+- Created a source gem rake task
+- Created a 'hint' file if the source gem is used directly
+- Changed file permissions on archives
+- Changed archives to be specific to platform (.zip on windows, .tar.gz
+otherwise)
+- Changed default rake task to only build library, not gem
+- Added a gem rake task
+
+=====0.1.0 -- 2008/10/15
+- Initial Release
+- Wraps DBCAPI functionality
+- Includes a simple unit test suite
+

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gem 'ffi'

data/LICENSE

@@ -0,0 +1,23 @@
+/*====================================================
+*
+*   Copyright 2012 iAnywhere Solutions, Inc.
+*
+* 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.
+*
+* While not a requirement of the license, if you do modify this file, we
+* would appreciate hearing about it.   Please email sqlany_interfaces@sybase.com
+*
+*
+*====================================================*/

data/README.md

@@ -0,0 +1,102 @@
+SQL Anywhere Ruby Driver
+------------------------
+This is a native SQL Anywhere driver for Ruby. This library wraps the 
+functionality provided by the SQL Anywhere DBCAPI library. This driver
+is intended to be a base-level library to be used by interface libraries
+such as Ruby-DBI and ActiveRecord.
+
+This driver can be used with SQL Anywhere 10 and later versions.
+
+This driver is licensed under the Apache License, Version 2.
+
+The official code repository is located on GitHub. The repository can be cloned with:
+
+   git clone git://github.com/sqlanywhere/sqlanywhere.git
+
+==Running Unit Tests==
+
+1. Change to the the <tt>test</tt> directory
+
+    cd test
+
+2. Create a testing database:
+
+    dbinit test
+
+3. Start the testing database:
+
+    dbeng12 test.db
+ 
+4. Create the test schema:
+
+    dbisql -c "eng=test;uid=dba;pwd=sql" test.sql
+
+5. Run the unit tests:
+
+    ruby sqlanywhere_test.rb
+
+<b>If the tests fail to run, make sure you have set up the SQL Anywhere environment variables correctly.</b> For more information,
+review the online documentation here [http://dcx.sybase.com/index.html#1200/en/dbadmin/da-envvar.html].
+
+Sample
+------
+
+This script makes a connection, prints <tt>Successful Ruby Connection</tt> to the SQL
+Anywhere console, then disconnects.
+  
+   # load the SQLAnywhere gem
+
+   begin
+
+     require 'rubygems'
+
+     gem 'sqlanywhere'
+
+     unless defined? SQLAnywhere
+
+       require 'sqlanywhere'
+
+     end
+
+   end
+
+   # create an interface
+
+   api = SQLAnywhere::SQLAnywhereInterface.new()
+
+   # initialize the interface (loads the DLL/SO)
+
+   SQLAnywhere::API.sqlany_initialize_interface( api )
+
+   # initialize our api object
+
+   api.sqlany_init()
+
+   # create a connection
+
+   conn = api.sqlany_new_connection()
+
+   # establish a connection
+
+   api.sqlany_connect(conn, "uid=dba;pwd=sql")
+
+   # execute a query without a result set
+
+   api.sqlany_execute_immediate(conn, "MESSAGE 'Successful Ruby Connection'")
+
+   # disconnect from the database
+
+   api.sqlany_disconnect(conn)
+
+   # free the connection resources
+
+   api.sqlany_free_connection(conn)
+
+   # free resources the api object uses
+
+   api.sqlany_fini()
+
+   # close the interface
+   
+   SQLAnywhere::API.sqlany_finalize_interface( api )
+

data/lib/api.rb

@@ -0,0 +1,8 @@
+module SQLAnywhere::API
+
+  def self.sqlany_initialize_interface(api, path=nil)
+  end
+
+  def self.sqlany_finalize_interface(api)
+  end
+end

data/lib/bind_param.rb

@@ -0,0 +1,92 @@
+require 'ffi'
+
+class SQLAnywhere::BindParam < FFI::Struct
+
+  layout(
+    :direction, SQLAnywhere::DataDirection,
+    :value, SQLAnywhere::DataValue,
+    :name, :string,
+    )
+
+  def get_name
+    self[:name]
+  end
+
+  def get_direction
+    self[:direction]
+  end
+
+  def set_direction d
+    self[:direction] = d
+  end
+
+  def inspect
+    "<#{self.class} direction: #{self[:direction]}, name: #{self[:name]}, value: #{self[:value].inspect}>"
+  end
+
+  def set_value(value)
+
+    self[:value][:is_null] = FFI::MemoryPointer.new(SQLAnywhere::Bool, 1, true)
+
+    if self[:direction] == :input
+
+      case value
+      when String
+        self[:value][:length] = FFI::MemoryPointer.new(SQLAnywhere::SIZE_T, 1, false)
+        length = value.bytesize
+        SQLAnywhere.write_size_t(self[:value][:length], length)
+        self[:value][:buffer] = FFI::MemoryPointer.new(:char, length + 1, false)
+
+        self[:value][:buffer].put_string(0, value)
+        self[:value][:type] = :string
+      when Fixnum
+        self[:value][:buffer] = FFI::MemoryPointer.new(:long, 1, false)
+        self[:value][:type] = :val64
+        byte_array = [value].pack('q')
+        byte_array.each_byte.each_with_index do |b, offset|
+          self[:value][:buffer].put_char(offset, b)
+        end
+      when Bignum
+        self[:value][:buffer] = FFI::MemoryPointer.new(:long_long, 1, false)
+        self[:value][:type] = :val64
+        byte_array = [value].pack('Q')
+        byte_array.each_byte.each_with_index do |b, offset|
+          self[:value][:buffer].put_char(offset, b)
+        end
+      when Float
+        self[:value][:buffer] = FFI::MemoryPointer.new(:double, 1, false)
+        self[:value][:buffer].write_double(value)
+        self[:value][:type] = :double
+      when nil
+        self[:value][:is_null].write_int(1)
+        self[:value][:buffer] = FFI::MemoryPointer.new(:int, 1, false)
+        self[:value][:type] = :val32
+      else
+        raise "Cannot convert type (#{value.class}). Must be STRING, FIXNUM, BIGNUM, FLOAT, or NIL"
+      end
+
+    else
+      self[:value][:buffer] = FFI::MemoryPointer.new(:char,
+        case self[:value][:type]
+        when :string
+          self[:value][:buffer_size]
+        when :double
+          FFI::Type::FLOAT.size # Is this right? it's what the old code does
+        when :val64, :uval64
+          FFI::Type::LONG_LONG.size
+        when :val32, :uval32
+          FFI::Type::INT.size
+        when :val16, :uval16
+          FFI::Type::SHORT.size
+        when :val8, :uval8
+          FFI::Type::CHAR.size
+        else
+          raise "Type unknown (#{self[:value][:type]})"
+        end
+        )
+        
+    end
+    nil
+  end
+
+end

data/lib/bind_param_info.rb

@@ -0,0 +1,12 @@
+require 'ffi'
+
+# http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-a-sqlany-bind-param-info-str.html
+class SQLAnywhere::BindParamInfo < FFI::Struct
+
+  layout(
+    :name, :string,
+    :direction, SQLAnywhere::DataDirection,
+    :input_value, SQLAnywhere::DataValue,
+    :output_value, SQLAnywhere::DataValue,
+  )
+end

data/lib/bool.rb

@@ -0,0 +1,13 @@
+require 'ffi'
+
+class SQLAnywhere::Bool < FFI::Struct
+
+  layout(
+    :value, :int32,
+  )
+
+  def read
+    self[:value]
+  end
+
+end

data/lib/column_info.rb

@@ -0,0 +1,18 @@
+require 'ffi'
+
+# http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-a-sqlany-column-info-str.html
+class SQLAnywhere::ColumnInfo < FFI::Struct
+
+  layout(
+    # The name of the column (null-terminated).
+    # The string can be referenced as long as the result set object is not freed.
+    :name, :string,
+    :type, SQLAnywhere::DataType,
+    :native_type, SQLAnywhere::NativeType,
+    :precision, :ushort,
+    :scale, :ushort,
+    :max_size, SQLAnywhere::SIZE_T,
+    :nullable, SQLAnywhere::Bool,
+    )
+
+end

data/lib/data_info.rb

@@ -0,0 +1,12 @@
+require 'ffi'
+
+# http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-a-sqlany-data-info-str.html
+class SQLAnywhere::DataInfo < FFI::Struct
+
+  layout(
+    :type, SQLAnywhere::DataType,
+    :is_null, SQLAnywhere::Bool,
+    :data_size, SQLAnywhere::SIZE_T,
+    )
+
+end

data/lib/data_value.rb

@@ -0,0 +1,60 @@
+require 'ffi'
+
+# 
+class SQLAnywhere::DataValue < FFI::Struct
+
+  layout(
+    :buffer, :pointer, # deliberately not a string
+    :buffer_size, SQLAnywhere::SIZE_T,
+    :length, :pointer,
+    :type, SQLAnywhere::DataType,
+    :is_null, :pointer,
+  )
+
+  def inspect
+    "<#{self.class} value: #{self.value}, buffer_size: #{self[:buffer_size]}, is_null: #{self.is_null?}, length: #{self.length}, type: #{self[:type]}, buffer: #{self[:buffer]}, length_pointer: #{self[:length]}>"
+  end
+
+
+  def is_null?
+    return nil if self[:is_null].null?
+    self[:is_null].read_uint == 1
+  end
+
+  def length
+    return nil if self[:length].null?
+    self[:length].read_uint
+  end
+
+  def value
+    return nil if is_null?
+
+    case self[:type]
+    #when :invalid_type
+    when :binary, :string
+      self[:buffer].get_string(0, length)
+    when :double
+      self[:buffer].read_double
+    when :val64 # 64 bit integer
+      self[:buffer].read_long_long
+    when :unsigned_val64 # 64 bit unsigned integer
+      self[:buffer].read_ulong_long
+    when :val32
+      self[:buffer].read_int
+    when :unsigned_val32
+      self[:buffer].read_uint
+    when :val16
+      self[:buffer].read_short
+    when :unsigned_val16
+      self[:buffer].read_ushort
+    when :val8
+      self[:buffer].read_char
+    when :unsigned_val8
+      self[:buffer].read_uchar
+    else
+      raise "Type not yet implemented #{self[:type]}"
+    end
+
+  end
+
+end

data/lib/sql_anywhere_interface.rb

@@ -0,0 +1,113 @@
+require 'ffi'
+
+class SQLAnywhere::SQLAnywhereInterface
+
+  extend FFI::Library
+  ffi_lib 'dbcapi'
+
+  def sqlany_init(app_name = "RUBY", api_version = SQLAnywhere::API_VERSION_2, version_available = FFI::MemoryPointer.new(:int, 1, false))
+    sqlany_init_ app_name, api_version, version_available
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-init-met.html
+  attach_function :sqlany_init_, :sqlany_init, [:string, :uint, :pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-new-connection-met.html
+  attach_function :sqlany_new_connection, [], :pointer
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-connect-met.html
+  attach_function :sqlany_connect, [:pointer, :string], :int
+
+  def sqlany_error(connection)
+    size = 255
+    buffer = FFI::MemoryPointer.new(:char, size, false)
+    code = sqlany_error_ connection, buffer, size
+    return code, buffer.read_string
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-error-met.html
+  attach_function :sqlany_error_, :sqlany_error, [:pointer, :pointer, SQLAnywhere::SIZE_T], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-execute-direct-met.html
+  attach_function :sqlany_execute_direct, [:pointer, :string], :pointer
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-fetch-next-met.html
+  attach_function :sqlany_fetch_next, [:pointer], :int
+
+  def sqlany_get_column(statement, column_number)
+    buffer = SQLAnywhere::DataValue.new
+    result = sqlany_get_column_(statement, column_number, buffer)
+    return [0, nil] if result == 0
+    [result, buffer.value]
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-get-column-met.html
+  attach_function :sqlany_get_column_, :sqlany_get_column, [:pointer, :uint32, :pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-free-stmt-met.html
+  attach_function :sqlany_free_stmt, [:pointer], :void
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-execute-immediate-met.html
+  attach_function :sqlany_execute_immediate, [:pointer, :string], :int
+
+  def sqlany_disconnect(connection)
+    sqlany_disconnect_(connection)
+    return nil
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-disconnect-met.html
+  attach_function :sqlany_disconnect_, :sqlany_disconnect, [:pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-free-connection-met.html
+  attach_function :sqlany_free_connection, [:pointer], :void
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-fini-met.html
+  attach_function :sqlany_fini, [], :void
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-prepare-met.html
+  attach_function :sqlany_prepare, [:pointer, :string], :pointer
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-num-cols-met.html
+  attach_function :sqlany_num_cols, [:pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-commit-met.html
+  attach_function :sqlany_commit, [:pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-execute-met.html
+  attach_function :sqlany_execute, [:pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-rollback-met.html
+  attach_function :sqlany_rollback, [:pointer], :int
+
+  def sqlany_describe_bind_param(statement, index)
+    bind_parameter = SQLAnywhere::BindParam.new
+    result = sqlany_describe_bind_param_(statement, index, bind_parameter)
+    [result, bind_parameter]
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-describe-bind-param-met.html
+  attach_function :sqlany_describe_bind_param_, :sqlany_describe_bind_param, [:pointer, :uint32, :pointer], :int
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-bind-param-met.html
+  attach_function :sqlany_bind_param, [:pointer, :uint, :pointer], :int
+
+  def sqlany_get_column_info(statement, column_number)
+
+    info = SQLAnywhere::ColumnInfo.new
+    
+    result = sqlany_get_column_info_(statement, column_number, info)
+    [result, column_number, info[:name], info[:type], info[:native_type], info[:precision], info[:scale], info[:max_size], info[:nullable].read]
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-get-column-info-met.html
+  attach_function :sqlany_get_column_info_, :sqlany_get_column_info, [:pointer, :uint, :pointer], :int
+
+  def sqlany_sqlstate(connection)
+    size = 255
+    buffer = FFI::MemoryPointer.new(:char, size, false)
+    used = sqlany_sqlstate_(connection, buffer, size)
+    buffer.read_string(used)
+  end
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-sqlstate-met.html
+  attach_function :sqlany_sqlstate_, :sqlany_sqlstate, [:pointer, :pointer, SQLAnywhere::SIZE_T], SQLAnywhere::SIZE_T
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-clear-error-met.html
+  attach_function :sqlany_clear_error, [:pointer], :void
+
+  # http://dcx.sybase.com/1200/en/dbprogramming/programming-sacpp-sacapi-h-fil-sqlany-num-params-met.html
+  attach_function :sqlany_num_params, [:pointer], :int
+end