ffi-sybase 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ffi-sybase.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jari Bakken
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,25 @@
+= ffi-sybase
+
+Ruby/FFI bindings for Sybase's Open Client library.
+
+= See also
+
+* http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.infocenter.dc35570.1550/html/clcprgde/title.htm
+
+= Dependencies
+
+* ffi
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Jari Bakken. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/TODO

@@ -0,0 +1,10 @@
+soon:
+
+  - Sybase::Client wraps Context/Connection
+  - simple specs
+  
+maybe:
+  
+  - Async / EM
+  
+

data/examples/sp_who.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'pp'
+require 'ffi-sybase'
+
+unless ARGV.size == 3
+  abort("USAGE: #{$PROGRAM_NAME} <db> <user> <pass>")
+end
+
+db, user, pass = *ARGV
+
+Sybase::Context.new do |ctx|
+  ctx.callbacks.library { |message| puts "library : #{message}"  }
+  ctx.callbacks.client  { |message| puts "client  : #{message}"  }
+  ctx.callbacks.server  { |message| puts "server  : #{message}"  }
+
+  Sybase::Connection.new(ctx, :username => user, :password => pass) do |conn|
+    conn.connect db
+    pp Sybase::Command.new(conn, "sp_who").execute
+  end
+end

data/ffi-sybase.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sybase/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ffi-sybase"
+  s.version     = Sybase::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jari Bakken"]
+  s.email       = ["jari.bakken@gmail.com"]
+  s.homepage    = "http://github.com/jarib/ffi-sybase"
+  s.summary     = %q{Ruby/FFI bindings for Sybase OCS}
+  s.description = %q{Ruby/FFI bindings for Sybase's Open Client library.}
+
+  s.rubyforge_project = "ffi-sybase"
+
+  s.add_dependency "ffi", ">= 0.6.3"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/ffi-sybase.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'socket'
+require 'ffi'
+
+module Sybase
+  class Error < StandardError; end
+end
+
+require "sybase/version"
+require "sybase/constants"
+require "sybase/structs/message"
+require "sybase/structs/client_message"
+require "sybase/structs/server_message"
+require "sybase/structs/column_data"
+require "sybase/structs/data_format"
+require "sybase/lib"
+require "sybase/context"
+require "sybase/connection"
+require "sybase/command"

data/lib/sybase/command.rb

@@ -0,0 +1,209 @@
+module Sybase
+  class Command
+
+    def initialize(connection, str)
+      FFI::MemoryPointer.new(:pointer) do |ptr|
+        Lib.check Lib.ct_cmd_alloc(connection, ptr), "ct_cmd_alloc"
+        @ptr = FFI::AutoPointer.new(ptr.read_pointer, Lib.method(:ct_cmd_drop))
+      end
+
+      @str = str.to_s
+    end
+
+    def execute
+      set_command
+      send
+      results
+    ensure
+      finish
+    end
+
+    def finish
+      to_ptr.free
+      @ptr = nil
+    end
+
+    def to_ptr
+      @ptr or raise "command #{self} already ran or was not initialized"
+    end
+
+    private
+
+    def set_command
+      Lib.check Lib.ct_command(to_ptr, CS_LANG_CMD, @str, @str.bytesize, CS_UNUSED)
+    end
+
+    def send
+      Lib.check Lib.ct_send(to_ptr), "ct_send failed"
+    end
+
+    def cancel
+      Lib.ct_cancel(nil, to_ptr, CS_CANCEL_CURRENT)
+    end
+
+    COMMAND_RESULTS = {
+      CS_CMD_SUCCEED    => :succeed,
+      CS_CMD_DONE       => :done,
+      CS_CMD_FAIL       => :fail,
+      CS_ROW_RESULT     => :row,
+      CS_CURSOR_RESULT  => :cursor,
+      CS_PARAM_RESULT   => :param,
+      CS_COMPUTE_RESULT => :compute,
+      CS_STATUS_RESULT  => :status
+    }
+
+    def results
+      intptr = FFI::MemoryPointer.new(:int)
+
+      state = :initial
+
+      returned = []
+
+      while successful? intptr
+        restype = intptr.read_int
+        restype = COMMAND_RESULTS[restype] || restype
+
+        case restype
+        when :succeed, # no row - e.g. insert/update
+             :done     # results completely processed
+          returned << Result.new(restype, nil, result_info(CS_ROW_COUNT), result_info(CS_TRANS_STATE))
+        when :fail
+          returned << Result.new(restype, nil, result_info(CS_ROW_COUNT), result_info(CS_TRANS_STATE))
+        when :row,
+             :cursor,
+             :param,
+             :compute,
+             :status
+
+          columns, rows = fetch_data
+          returned << Result.new(restype, :columns => columns, :rows => rows)
+        else
+          returned << Result.new(restype, nil, result_info(CS_ROW_COUNT), result_info(CS_TRANS_STATE))
+        end
+
+        # check context timeout?
+      end
+
+      returned
+    end
+
+    class Result
+      def initialize(type, data, row_count = nil, transaction_state = nil)
+        @type              = type
+        @data              = data
+        @row_count         = row_count
+        @transaction_state = transaction_state
+      end
+    end # Result
+
+    def successful?(intptr)
+      @return_code = Lib.ct_results(to_ptr, intptr)
+      @return_code == CS_SUCCEED
+    end
+
+    def fetch_data
+      num_cols = fetch_column_count
+
+      column_datas = Array.new(num_cols) { ColumnData.new }
+
+      num_cols.times do |i|
+        cd = column_datas[i]
+        df = cd.format
+
+        Lib.check Lib.ct_describe(to_ptr, i + 1, df)
+        type = df[:datatype]
+
+        case type
+        when CS_TINYINT_TYPE,
+             CS_SMALLINT_TYPE,
+             CS_INT_TYPE,
+             CS_BIT_TYPE,
+             CS_DECIMAL_TYPE,
+             CS_NUMERIC_TYPE
+          df[:maxlength] = FFI.type_size(:int)
+          df[:datatype]  = CS_INT_TYPE
+          df[:format]    = CS_FMT_UNUSED
+
+          cd.int_pointer!
+        when CS_REAL_TYPE, CS_FLOAT_TYPE
+          # not sure about this
+          df[:maxlength] = FFI.type_size(:double)
+          df[:datatype]  = CS_FLOAT_TYPE
+          df[:format]    = CS_FMT_UNUSED
+
+          cd.double_pointer!
+        else # treat as String
+          df[:maxlength] = Lib.display_length(df) + 1
+
+          if type == CS_IMAGE_TYPE
+            df[:format] = CS_FMT_UNUSED
+          else
+            df[:format] = CS_FMT_NULLTERM
+            df[:datatype] = CS_CHAR_TYPE
+          end
+
+          cd.char_pointer!(df[:maxlength])
+        end
+
+        bind i, df, cd
+      end
+
+      rows_read_ptr = FFI::MemoryPointer.new(:int)
+      row_count     = 0
+
+      columns       = column_datas.map { |cd| cd.format.name }
+      values        = []
+
+      while (code = fetch_row(rows_read_ptr)) == CS_SUCCEED || code == CS_ROW_FAIL
+        # increment row count
+        row_count += rows_read_ptr.read_int
+
+        if code == CS_ROW_FAIL
+          raise Error, "error on row #{row_count}"
+        end
+
+        values << column_datas.map { |e| e.value }
+      end
+
+      # done processing rows, check final return code
+      case code
+      when CS_END_DATA
+        # all good
+      when CS_FAIL
+        raise Error, "ct_fetch() failed"
+      else
+        raise Error, "unexpected return code: #{code}"
+      end
+
+      [columns, values]
+    ensure
+      # ?
+    end
+
+    def fetch_row(rows_read_ptr)
+      Lib.ct_fetch(to_ptr, CS_UNUSED, CS_UNUSED, CS_UNUSED, rows_read_ptr)
+    end
+
+    def bind(index, data_format, column_data)
+      Lib.check Lib.ct_bind(to_ptr, index + 1, data_format, column_data.pointer, column_data.valuelen_pointer, column_data.indicator_pointer)
+    end
+
+    def fetch_column_count
+      num_cols = result_info(CS_NUMDATA)
+
+      if num_cols <= 0
+        cancel
+        raise Error, "bad column count (#{num_cols})"
+      end
+
+      num_cols
+    end
+
+    def result_info(operation)
+      int_ptr = FFI::MemoryPointer.new(:int)
+      Lib.check Lib.ct_res_info(to_ptr, operation, int_ptr, CS_UNUSED, nil), "ct_res_info failed"
+      num_cols = int_ptr.read_int
+    end
+
+  end # Command
+end # Sybase

data/lib/sybase/connection.rb

@@ -0,0 +1,132 @@
+module Sybase
+  class Connection
+    PROPERTIES = {
+      :username    => [ CS_USERNAME,    :string ],
+      :password    => [ CS_PASSWORD,    :string ],
+      :appname     => [ CS_APPNAME,     :string ],
+      :tds_version => [ CS_TDS_VERSION, :int    ],
+      :hostname    => [ CS_HOSTNAME,    :string ]
+    }
+
+
+    def initialize(context, opts ={})
+      @context = context
+
+      FFI::MemoryPointer.new(:pointer) { |ptr|
+        Lib.check Lib.ct_con_alloc(context, ptr), "ct_con_alloc"
+        @ptr = FFI::AutoPointer.new(ptr.read_pointer, Lib.method(:ct_con_drop))
+      }
+
+      opts.each do |key, value|
+        self[key] = value
+      end
+
+      unless opts.has_key?(:hostname)
+        self[:hostname] = Socket.gethostname
+      end
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          close
+        end
+      end
+    end
+
+    def debug!
+      Lib.check Lib.ct_debug(@context, to_ptr, CS_SET_FLAG, CS_DBG_ALL, nil, CS_UNUSED)
+    end
+
+    def close
+      Lib.check Lib.ct_close(@ptr, CS_UNUSED), "ct_close"
+    end
+
+    def [](key)
+      property, type = property_type_for(key)
+      case type
+      when :string
+        get_string_property property
+      when :int
+        get_int_property property
+      end
+    end
+
+    def []=(key, value)
+      property, type = property_type_for(key)
+
+      case type
+      when :string
+        set_string_property property, value
+      when :int
+        set_int_property property, value
+      else
+        raise Error, "invalid type: #{type.inspect}"
+      end
+    end
+
+    def property_type_for(key)
+      PROPERTIES.fetch(key) { |key|
+        raise ArgumentError, "invalid option: #{key.inspect}, expected one of #{PROPERTIES.keys.inspect}"
+      }
+    end
+
+    def username=(user)
+      set_string CS_USERNAME, user
+    end
+
+    def username
+      get_string CS_USERNAME
+    end
+
+    def password=(password)
+      set_string CS_PASSWORD, password
+    end
+
+    def password
+      get_string CS_PASSWORD
+    end
+
+    def appname=(name)
+      set_string CS_APPNAME, name
+    end
+
+    def appname
+      get_string CS_APPNAME, name
+    end
+
+    def connect(server)
+      server = server.to_s
+      Lib.check Lib.ct_connect(@ptr, server,  server.bytesize), "connect(#{server.inspect}) failed"
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    private
+
+    def set_string_property(property, string)
+      Lib.check Lib.ct_con_props(@ptr, CS_SET, property, string.to_s, CS_NULLTERM, nil), "ct_con_prop(#{property} => #{string.inspect}) failed"
+    end
+
+    def get_string_property(property)
+      FFI::MemoryPointer.new(:string) { |ptr| get_property(property, ptr) }.read_string
+    end
+
+    def get_int_property(property)
+      FFI::MemoryPointer.new(:int) { |ptr| get_property(property, ptr) }.read_int
+    end
+
+    def set_int_property(property, int)
+      ptr = FFI::MemoryPointer.new(:int)
+      ptr.write_int(int)
+
+      Lib.check Lib.ct_con_props(@ptr, CS_SET, property, ptr, CS_UNUSED, nil), "ct_con_prop(#{property} => #{int.inspect}) failed"
+    end
+
+    def get_property(property, ptr)
+      Lib.check Lib.ct_con_props(@ptr, CS_GET, property, ptr, CS_UNUSED, nil), "ct_con_prop(CS_GET, #{property}) failed"
+    end
+  end # Connection
+end # Sybase

data/lib/sybase/constants.rb

@@ -0,0 +1,165 @@
+module Sybase
+  DEFAULT_CTLIB_VERSION = 15001
+
+  MAX_CHAR_BUF          = 1024
+
+  CS_CONV_ERR           = -100
+  CS_EXTERNAL_ERR       = -200
+  CS_INTERNAL_ERR       = -300
+
+  CS_TDS_40             = 7360
+  CS_TDS_42             = 7361
+  CS_TDS_46             = 7362
+  CS_TDS_495            = 7363
+  CS_TDS_50             = 7364
+
+  CS_SET_FLAG           = 1700
+  CS_CLEAR_FLAG         = 1701
+  CS_DBG_ALL            = 1
+  CS_DBG_ASYNC          = 2
+  CS_DBG_ERROR          = 4
+
+  CS_CLIENTMSG_CB       = 3
+  CS_GET                = 33
+  CS_MAX_CHAR           = 256
+  CS_MAX_NAME           = 255
+  CS_MAX_MSG            = 1024
+  CS_MESSAGE_CB         = 9119
+  CS_NULLTERM           = -9
+  CS_SERVERMSG_CB       = 2
+  CS_SET                = 34
+  CS_SQLSTATE_SIZE      = 8
+  CS_SUCCEED            = 1
+  CS_FAIL               = 0
+  CS_UNUSED             = -99999
+  CS_CANCEL_CURRENT     = 6000
+  CS_FMT_UNUSED         = 0
+  CS_FMT_NULLTERM       = 1
+
+  CS_SYNC_IO = 8111
+  CS_ASYNC_IO = 8112
+  CS_DEFER_IO = 8113
+
+  # server options
+  CS_OPT_CHARSET        = 5010
+  CS_OPT_PARSEONLY      = 5018
+
+  # ct_command types
+  CS_LANG_CMD           = 148
+  CS_RPC_CMD            = 149
+  CS_MSG_CMD            = 150
+  CS_SEND_DATA_CMD      = 152
+
+  # connection properties
+  CS_USERNAME           = 9100
+  CS_PASSWORD           = 9101
+  CS_APPNAME            = 9102
+  CS_HOSTNAME           = 9103
+  CS_LOGIN_STATUS       = 9104
+  CS_TDS_VERSION        = 9105
+  CS_CHARSETCNV         = 9106
+  CS_PACKETSIZE         = 9107
+  CS_USERDATA           = 9108
+  CS_COMMBLOCK          = 9109
+  CS_NETIO              = 9110
+  CS_NOINTERRUPT        = 9111
+  CS_TEXTLIMIT          = 9112
+  CS_HIDDEN_KEYS        = 9113
+  CS_VERSION            = 9114
+  CS_IFILE              = 9115
+  CS_LOGIN_TIMEOUT      = 9116
+  CS_TIMEOUT            = 9117
+  CS_MAX_CONNECT        = 9118
+  CS_EXPOSE_FMTS        = 9120
+  CS_EXTRA_INF          = 9121
+  CS_TRANSACTION_NAME   = 9122
+  CS_ANSI_BINDS         = 9123
+  CS_BULK_LOGIN         = 9124
+  CS_LOC_PROP           = 9125
+  CS_CUR_STATUS         = 9126
+  CS_CUR_ID             = 9127
+  CS_CUR_NAME           = 9128
+  CS_CUR_ROWCOUNT       = 9129
+  CS_PARENT_HANDLE      = 9130
+  CS_EED_CMD            = 9131
+  CS_DIAG_TIMEOUT       = 9132
+  CS_DISABLE_POLL       = 9133
+  CS_NOTIF_CMD          = 9134
+  CS_SEC_ENCRYPTION     = 9135
+  CS_SEC_CHALLENGE      = 9136
+  CS_SEC_NEGOTIATE      = 9137
+  CS_MEM_POOL           = 9138
+  CS_USER_ALLOC         = 9139
+  CS_USER_FREE          = 9140
+  CS_ENDPOINT           = 9141
+  CS_NO_TRUNCATE        = 9142
+  CS_CON_STATUS         = 9143
+  CS_VER_STRING         = 9144
+  CS_ASYNC_NOTIFS       = 9145
+  CS_SERVERNAME         = 9146
+
+  CS_SEND_BULK_CMD      = 153
+
+  # ct_results
+  CS_ROW_RESULT         = 4040
+  CS_CURSOR_RESULT      = 4041
+  CS_PARAM_RESULT       = 4042
+  CS_STATUS_RESULT      = 4043
+  CS_MSG_RESULT         = 4044
+  CS_COMPUTE_RESULT     = 4045
+  CS_CMD_DONE           = 4046
+  CS_CMD_SUCCEED        = 4047
+  CS_CMD_FAIL           = 4048
+  CS_ROWFMT_RESULT      = 4049
+  CS_COMPUTEFMT_RESULT  = 4050
+  CS_DESCRIBE_RESULT    = 4051
+  CS_END_RESULTS        = CS_EXTERNAL_ERR - 5
+
+  # ct_res_info
+  CS_ROW_COUNT          = 800
+  CS_NUMDATA            = 803
+  CS_MSGTYPE            = 806
+  CS_TRANS_STATE        = 808
+
+  # ct_fetch
+  CS_ROW_FAIL           = CS_EXTERNAL_ERR - 3
+  CS_END_DATA           = CS_EXTERNAL_ERR - 4
+
+  # data types
+  CS_ILLEGAL_TYPE       = -1
+  CS_CHAR_TYPE          = 0
+  CS_BINARY_TYPE        = 1
+  CS_LONGCHAR_TYPE      = 2
+  CS_LONGBINARY_TYPE    = 3
+  CS_TEXT_TYPE          = 4
+  CS_IMAGE_TYPE         = 5
+  CS_TINYINT_TYPE       = 6
+  CS_SMALLINT_TYPE      = 7
+  CS_INT_TYPE           = 8
+  CS_REAL_TYPE          = 9
+  CS_FLOAT_TYPE         = 10
+  CS_BIT_TYPE           = 11
+  CS_DATETIME_TYPE      = 12
+  CS_DATETIME4_TYPE     = 13
+  CS_MONEY_TYPE         = 14
+  CS_MONEY4_TYPE        = 15
+  CS_NUMERIC_TYPE       = 16
+  CS_DECIMAL_TYPE       = 17
+  CS_VARCHAR_TYPE       = 18
+  CS_VARBINARY_TYPE     = 19
+  CS_LONG_TYPE          = 20
+  CS_SENSITIVITY_TYPE   = 21
+  CS_BOUNDARY_TYPE      = 22
+  CS_VOID_TYPE          = 23
+  CS_USHORT_TYPE        = 24
+  CS_UNICHAR_TYPE       = 25
+  CS_BLOB_TYPE          = 26
+  CS_DATE_TYPE          = 27
+  CS_TIME_TYPE          = 28
+  CS_UNITEXT_TYPE       = 29
+  CS_BIGINT_TYPE        = 30
+  CS_USMALLINT_TYPE     = 31
+  CS_UINT_TYPE          = 32
+  CS_UBIGINT_TYPE       = 33
+  CS_XML_TYPE           = 34
+end

data/lib/sybase/context.rb

@@ -0,0 +1,71 @@
+module Sybase
+  class Context
+    def initialize(version = DEFAULT_CTLIB_VERSION)
+      @version = Integer(version)
+
+      FFI::MemoryPointer.new(:pointer) do |ptr|
+        Lib.check Lib.cs_ctx_alloc(@version, ptr), "cs_ctx_alloc failed"
+        @ptr = FFI::AutoPointer.new(ptr.read_pointer, Lib.method(:cs_ctx_drop))
+      end
+
+      Lib.check Lib.ct_init(@ptr, @version), "ct_init failed"
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          exit
+        end
+      end
+    end
+
+    def sync=(bool)
+      FFI::MemoryPointer.new(:int) do |ptr|
+        ptr.write_int(bool ? CS_SYNC_IO : CS_ASYNC_IO) # CS_DEFER_IO ?
+        Lib.check Lib.ct_config(@ptr, CS_SET, CS_NETIO, ptr, CS_UNUSED, nil)
+      end
+    end
+
+    def callbacks
+      @callbacks ||= Callbacks.new self
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    def exit
+      Lib.check Lib.ct_exit(@ptr, CS_UNUSED), "ct_exit failed"
+    end
+
+    private
+
+    class Callbacks
+      def initialize(context)
+        @context = context
+      end
+
+      def library(&cb)
+        actual_callback = FFI::Function.new(:int, [:pointer, :pointer]) { |context, message|
+          cb.call ClientMessage.new(message)
+          CS_SUCCEED
+        }
+        Lib.check Lib.cs_config(@context, CS_SET, CS_MESSAGE_CB, actual_callback, CS_UNUSED, nil)
+      end
+
+      def client(&cb)
+        Lib.check Lib.ct_callback(@context, nil, CS_SET, CS_CLIENTMSG_CB, lambda { |context, connection, message|
+          cb.call ClientMessage.new(message)
+          CS_SUCCEED
+        })
+      end
+
+      def server(&cb)
+        Lib.check Lib.ct_callback(@context, nil, CS_SET, CS_SERVERMSG_CB, lambda { |context, connection, message|
+            cb.call ServerMessage.new(message)
+            CS_SUCCEED
+        })
+      end
+    end # Callbacks
+  end # Context
+end # Sybase

data/lib/sybase/lib.rb

@@ -0,0 +1,264 @@
+module Sybase
+  module Lib
+    extend FFI::Library
+
+    suffix = RUBY_VERSION < '1.9' ? '' : '_r'
+
+    if FFI.type_size(:pointer) == 8
+      ffi_lib "sybct64#{suffix}"
+    else
+      ffi_lib "sybct#{suffix}"
+    end
+
+    # extern CS_RETCODE CS_PUBLIC cs_ctx_alloc PROTOTYPE((
+    #     CS_INT version,
+    #     CS_CONTEXT **outptr
+    #     ));
+
+    attach_function :cs_ctx_alloc, [:int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC cs_ctx_drop PROTOTYPE((
+    #     CS_CONTEXT *context
+    #     ));
+
+    attach_function :cs_ctx_drop, [:pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_init PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_INT version
+    #     ));
+
+    attach_function :ct_init, [:pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_config PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_INT action,
+    #     CS_INT property,
+    #     CS_VOID *buf,
+    #     CS_INT buflen,
+    #     CS_INT *outlen
+    #     ));
+
+    attach_function :ct_config, [:pointer, :int, :int, :pointer, :int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC cs_config PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_INT action,
+    #     CS_INT property,
+    #     CS_VOID *buf,
+    #     CS_INT buflen,
+    #     CS_INT *outlen
+    #     ));
+
+    attach_function :cs_config, [:pointer, :int, :int, :pointer, :int, :pointer], :int
+
+
+
+    callback :cs_clientmsg_cb, [:pointer, :pointer, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_callback PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_CONNECTION *connection,
+    #     CS_INT action,
+    #     CS_INT type,
+    #     CS_VOID *func
+    #     ));
+
+    attach_function :ct_callback, [:pointer, :pointer, :int, :int, :cs_clientmsg_cb], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_con_alloc PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_CONNECTION **connection
+    #     ));
+
+    attach_function :ct_con_alloc, [:pointer, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_con_props PROTOTYPE((
+    #     CS_CONNECTION *connection,
+    #     CS_INT action,
+    #     CS_INT property,
+    #     CS_VOID *buf,
+    #     CS_INT buflen,
+    #     CS_INT *outlen
+    #     ));
+
+    attach_function :ct_con_props, [:pointer, :int, :int, :pointer, :int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_connect PROTOTYPE((
+    #     CS_CONNECTION *connection,
+    #     CS_CHAR *server_name,
+    #     CS_INT snamelen
+    #     ));
+
+    attach_function :ct_connect, [:pointer, :pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_close PROTOTYPE((
+    #     CS_CONNECTION *connection,
+    #     CS_INT option
+    #     ));
+
+    attach_function :ct_close, [:pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_cmd_alloc PROTOTYPE((
+    #     CS_CONNECTION *connection,
+    #     CS_COMMAND **cmdptr
+    #     ));
+
+    attach_function :ct_cmd_alloc, [:pointer, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_cmd_drop PROTOTYPE((
+    #     CS_COMMAND *cmd
+    #     ));
+
+    attach_function :ct_cmd_drop, [:pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_cmd_props PROTOTYPE((
+    #     CS_COMMAND *cmd,
+    #     CS_INT action,
+    #     CS_INT property,
+    #     CS_VOID *buf,
+    #     CS_INT buflen,
+    #     CS_INT *outlen
+    #     ));
+
+    attach_function :ct_cmd_props, [:pointer, :int, :int, :pointer, :int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_command PROTOTYPE((
+    #     CS_COMMAND *cmd,
+    #     CS_INT type,
+    #     CS_CHAR *buf,
+    #     CS_INT buflen,
+    #     CS_INT option
+    #     ));
+
+    attach_function :ct_command, [:pointer, :int, :string, :int, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_send PROTOTYPE((
+    #     CS_COMMAND *cmd
+    #     ));
+
+    attach_function :ct_send, [:pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_results PROTOTYPE((
+    #     CS_COMMAND *cmd,
+    #     CS_INT *result_type
+    #     ));
+
+    attach_function :ct_results, [:pointer, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_close PROTOTYPE((
+    #     CS_CONNECTION *connection,
+    #     CS_INT option
+    #     ));
+
+    attach_function :close, [:pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_exit PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_INT option
+    #     ));
+
+    attach_function :ct_exit, [:pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_con_drop PROTOTYPE((
+    #     CS_CONNECTION *connection
+    #     ));
+
+    attach_function :ct_con_drop, [:pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_cancel PROTOTYPE((
+    #   CS_CONNECTION *connection,
+    #   CS_COMMAND *cmd,
+    #   CS_INT type
+    #   ));
+
+    attach_function :ct_cancel, [:pointer, :pointer, :int], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_res_info PROTOTYPE((
+    #   CS_COMMAND *cmd,
+    #   CS_INT operation,
+    #   CS_VOID *buf,
+    #   CS_INT buflen,
+    #   CS_INT *outlen
+    #   ));
+
+    attach_function :ct_res_info, [:pointer, :int, :pointer, :int, :pointer], :int
+
+
+    # extern CS_RETCODE CS_PUBLIC ct_describe PROTOTYPE((
+    #     CS_COMMAND *cmd,
+    #     CS_INT item,
+    #     CS_DATAFMT *datafmt
+    #     ));
+
+    attach_function :ct_describe, [:pointer, :int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_bind PROTOTYPE((
+    #   CS_COMMAND *cmd,
+    #   CS_INT item,
+    #   CS_DATAFMT *datafmt,
+    #   CS_VOID *buf,
+    #   CS_INT *outputlen,
+    #   CS_SMALLINT *indicator
+    #   ));
+
+    attach_function :ct_bind, [:pointer, :int, :pointer, :pointer, :pointer, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_fetch PROTOTYPE((
+    #   CS_COMMAND *cmd,
+    #   CS_INT type,
+    #   CS_INT offset,
+    #   CS_INT option,
+    #   CS_INT *count
+    #   ));
+
+    attach_function :ct_fetch, [:pointer, :int, :int, :int, :pointer], :int
+
+    # extern CS_RETCODE CS_PUBLIC ct_debug PROTOTYPE((
+    #     CS_CONTEXT *context,
+    #     CS_CONNECTION *connection,
+    #     CS_INT operation,
+    #     CS_INT flag,
+    #     CS_CHAR *filename,
+    #     CS_INT fnamelen
+    #     ));
+
+    attach_function :ct_debug, [:pointer, :pointer, :int, :int, :pointer, :int], :int
+
+    def self.check(code, msg = "error")
+      if code != CS_SUCCEED
+        raise Error, msg
+      end
+    end
+
+    def self.display_length(data_format)
+      len = case data_format[:datatype]
+            when CS_CHAR_TYPE, CS_LONGCHAR_TYPE, CS_VARCHAR_TYPE, CS_TEXT_TYPE, CS_IMAGE_TYPE
+              [data_format[:maxlength], MAX_CHAR_BUF].min
+            when CS_UNICHAR_TYPE
+              [data_format[:maxlength] / 2, MAX_CHAR_BUF].min
+            when CS_BINARY_TYPE, CS_VARBINARY_TYPE
+              [(2 * data_format[:maxlength]) + 2, MAX_CHAR_BUF].min
+            when CS_BIT_TYPE, CS_TINYINT_TYPE
+              3
+            when CS_SMALLINT_TYPE
+              6
+            when CS_INT_TYPE
+              11
+            when CS_REAL_TYPE, CS_FLOAT_TYPE
+              20
+            when CS_MONEY_TYPE, CS_MONEY4_TYPE
+              24
+            when CS_DATETIME_TYPE, CS_DATETIME4_TYPE
+              30
+            when CS_NUMERIC_TYPE, CS_DECIMAL_TYPE
+              CS_MAX_PREC + 2
+            else
+              12
+            end
+
+
+      [data_format[:name].size + 1, len].max
+    end
+  end # Lib
+end # Sybase

data/lib/sybase/structs/client_message.rb

@@ -0,0 +1,33 @@
+module Sybase
+  # typedef struct _cs_clientmsg
+  # {
+  #   CS_INT          severity;
+  #   CS_MSGNUM       msgnumber;
+  #   CS_CHAR         msgstring[CS_MAX_MSG];
+  #   CS_INT          msgstringlen;
+  #   CS_INT          osnumber;
+  #   CS_CHAR         osstring[CS_MAX_MSG];
+  #   CS_INT          osstringlen;
+  #   CS_INT          status;
+  #   CS_BYTE         sqlstate[CS_SQLSTATE_SIZE];
+  #   CS_INT          sqlstatelen;
+  # } CS_CLIENTMSG;
+
+  class ClientMessage < Message
+    layout :severity,     :int,
+           :msgnumber,    :uint,
+           :msgstring,    [:char, CS_MAX_MSG],
+           :msgstringlen, :int,
+           :osnumber,     :int,
+           :osstring,     [:char, CS_MAX_MSG],
+           :osstringlen,  :int,
+           :status,       :int,
+           :sqlstate,     [:uchar, CS_SQLSTATE_SIZE],
+           :sqlstatelen,  :int
+
+    def text
+      self[:msgstring].to_s.chomp
+    end
+
+  end # ClientMessage
+end

data/lib/sybase/structs/column_data.rb

@@ -0,0 +1,60 @@
+module Sybase
+  class ColumnData
+    attr_reader :pointer, :type, :format
+
+    def initialize
+      @pointer = nil
+      @type = nil
+      @format = DataFormat.new
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{(hash*2).to_s(16)} type=#{type.inspect} valuelen=#{valuelen} indicator=#{indicator}>"
+    end
+
+    def char_pointer!(size = 256)
+      @type = :char
+      @pointer = FFI::MemoryPointer.new(@type, size)
+    end
+
+    def int_pointer!
+      @type = :int
+      @pointer = FFI::MemoryPointer.new(@type)
+    end
+
+    def double_pointer!
+      @type = :double
+      @pointer = FFI::MemoryPointer.new(@type)
+    end
+
+    def valuelen_pointer
+      @valuelen_ptr ||= FFI::MemoryPointer.new(:int)
+    end
+
+    def indicator_pointer
+      @indicator_ptr ||= FFI::MemoryPointer.new(:int)
+    end
+
+    def valuelen
+      valuelen_pointer.read_int
+    end
+
+    def indicator
+      indicator_pointer.read_int
+    end
+
+    def value
+      case @type
+      when :int
+        @pointer.read_int
+      when :char
+        @pointer.get_bytes(0, valuelen - 1)
+      when :double
+        @pointer.read_double
+      else
+        raise Error, "uknown type #{type}"
+      end
+    end
+
+  end
+end

data/lib/sybase/structs/data_format.rb

@@ -0,0 +1,63 @@
+module Sybase
+
+  # typedef struct _cs_datafmt
+  # {
+  #   CS_CHAR   name[CS_MAX_NAME]; // CS_MAX_CHAR if >= Sybase 15
+  #   CS_INT    namelen;
+  #   CS_INT    datatype;
+  #   CS_INT    format;
+  #   CS_INT    maxlength;
+  #   CS_INT    scale;
+  #   CS_INT    precision;
+  #   CS_INT    status;
+  #   CS_INT    count;
+  #   CS_INT    usertype;
+  #   CS_LOCALE *locale;
+  # } CS_DATAFMT;
+
+
+  class DataFormat < FFI::Struct
+    attr_accessor :ruby_type
+
+    layout :name,       [:char, CS_MAX_CHAR],
+           :namelen,    :int,
+           :datatype,   :int,
+           :format,     :int,
+           :maxlength,  :int,
+           :scale,      :int,
+           :precision,  :int,
+           :status,     :int,
+           :count,      :int,
+           :usertype,   :int,
+           :locale,     :pointer
+
+    INTS = [:namelen, :datatype, :format, :maxlength, :scale, :precision, :status, :count, :usertype]
+
+    def reset!
+      INTS.each { |key| self[key] = 0 }
+    end
+
+    def inspect
+      "#<%s name=%s namelen=%d datatype=%d format=%d maxlength=%d scale=%d precision=%d status=%d count=%d usertype=%d locale=%s address=%x>" % [
+        self.class.name,
+        name.inspect,
+        self[:namelen],
+        self[:datatype],
+        self[:format],
+        self[:maxlength],
+        self[:scale],
+        self[:precision],
+        self[:status],
+        self[:count],
+        self[:usertype],
+        self[:locale].inspect,
+        to_ptr.address
+      ]
+    end
+
+    def name
+      self[:name].to_s
+    end
+  end
+
+end

data/lib/sybase/structs/message.rb

@@ -0,0 +1,27 @@
+module Sybase
+  class Message < FFI::Struct
+    def severity
+      (self[:severity] >> 8) & 0xff
+    end
+
+    def number
+      self[:msgnumber] & 0xff
+    end
+
+    def origin
+      (self[:msgnumber]) >> 16 & 0xff
+    end
+
+    def layer
+      (self[:msgnumber] >> 24) & 0x44
+    end
+
+    def inspect
+      "#<%s text=%s severity=%d number=%d origin=%d layer=%d>" % [self.class.name, text.inspect, severity, number, origin, layer]
+    end
+
+    def to_s
+      "%s (severity=%d number=%d origin=%d layer=%d)" % [text, severity, number, origin, layer]
+    end
+  end
+end

data/lib/sybase/structs/server_message.rb

@@ -0,0 +1,38 @@
+module Sybase
+  # typedef struct _cs_servermsg
+  # {
+  #   CS_MSGNUM msgnumber;
+  #   CS_INT            state;
+  #   CS_INT            severity;
+  #   CS_CHAR           text[CS_MAX_MSG];
+  #   CS_INT            textlen;
+  #   CS_CHAR           svrname[CS_MAX_CHAR];
+  #   CS_INT            svrnlen;
+  #   CS_CHAR           proc[CS_MAX_CHAR];
+  #   CS_INT            proclen;
+  #   CS_INT            line;
+  #   CS_INT            status;
+  #   CS_BYTE           sqlstate[CS_SQLSTATE_SIZE];
+  #   CS_INT            sqlstatelen;
+  # } CS_SERVERMSG;
+
+  class ServerMessage < Message
+    layout :msgnumber,   :uint,
+           :state,       :int,
+           :severity,    :int,
+           :text,        [:char, CS_MAX_MSG],
+           :textlen,     :int,
+           :svrname,     [:char, CS_MAX_CHAR],
+           :svrnlen,     :int,
+           :proc,        [:char, CS_MAX_CHAR],
+           :proclen,     :int,
+           :line,        :int,
+           :status,      :int,
+           :sqlstate,    [:uchar, CS_SQLSTATE_SIZE],
+           :sqlstatelen, :int
+
+    def text
+      self[:text].to_s.chomp
+    end
+  end
+end

data/lib/sybase/version.rb

@@ -0,0 +1,3 @@
+module Sybase
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: ffi-sybase
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jari Bakken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.3
+  type: :runtime
+  version_requirements: *id001
+description: Ruby/FFI bindings for Sybase's Open Client library.
+email: 
+- jari.bakken@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- TODO
+- examples/sp_who.rb
+- ffi-sybase.gemspec
+- lib/ffi-sybase.rb
+- lib/sybase/command.rb
+- lib/sybase/connection.rb
+- lib/sybase/constants.rb
+- lib/sybase/context.rb
+- lib/sybase/lib.rb
+- lib/sybase/structs/client_message.rb
+- lib/sybase/structs/column_data.rb
+- lib/sybase/structs/data_format.rb
+- lib/sybase/structs/message.rb
+- lib/sybase/structs/server_message.rb
+- lib/sybase/version.rb
+has_rdoc: true
+homepage: http://github.com/jarib/ffi-sybase
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: ffi-sybase
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ruby/FFI bindings for Sybase OCS
+test_files: []
+