Studi Kasus

Adalah satu hal yang lumrah dalam penerbitan dokumen invoice perusahaan menerapkan kodifikasi penomoran untuk setiap dokumen invoice yang diterbitkan, sebagai contoh: 30912/INV/EXP/III/2010. Hal ini dilakukan untuk mempermudah manajemen dan pengaturan atas dokumen yang dibuat. Permasalahannya adalah bagaimana jika kodifikasi tersebut bersifat dinamis, dalam artian bergantung pada pelanggan-nya, dalam arti misalnya: untuk pelangan PT. DAUN BUAH menggunakan format dokumen 30912/EXP/MAR/2010, sementara untuk PT. SEGARA PERKASA berformat 30912/EXP/03/2010, dan untuk PT. ABADI NUSA menggunakan format 30912/EXP/INV/2010. Hal ini tentunya akan menjadi kasus yang cukup menggelitik untuk dipecahkan.

Pada kasus tersebut, saya memecahkannya dengan membuat rutin khusus untuk menangani kodifikasi yang dinamis tersebut dengan cara melakukan parsing atas format dokumen yang digunakan. Sebagai contoh, dokumen bernomor 30912/EXP/MAR/2010 terdiri atas elemen-elemen berikut: nomor dokumen (30912), bulan (MAR) dan tahun (2010) adapun karakter lainnya dapat dianggap sebagai karakter penyerta (/EXP/).

Secara keseluruhan, format kodifikasi penomoran dokumen pada umumnya melibatkan dua variabel utama, yaitu tanggal, dan nomor dokumen itu sendiri. Atas dua jenis variabel tersebut kemudian kita bisa menyusun elemen-elemen pembentuk atas format nomor dokumen yang akan dibuat, dalam hal ini misalnya: X untuk sebagai nomor dokumen, D untuk tanggal, M untuk bulam, dan Y untuk tahun. Untuk lebih mempermudah pengimplementasian, saya menggunakan aturan yang diterapkan pada bahasa C/C++ untuk memformat tanggal dengan beberapa penambahan fleksibilitas. Sebagai contoh, berikut ini adalah contoh nomor dokumen dan format yang saya implementasikan:

30912/EXP/MAR/2010 = [XXXXX]/EXP/[MMM]/[YYYY]
Elemen bulan dalam hal ini menggunakan metode penamaan pendek (Jan, Feb, Mar, dst), untuk hal tersebut kita menggunakan M sebanyak 3 kali, kemudian karena format yang diinginkan adalah menggunakan kapitalisasi maka, ketiga elemen tersebut ditulis sebagai huruf kapital. Artinya, kalau menginginkan format 30912/EXP/mar/2010, maka tinggal menyesuaikannya sebagai [XXXXX]/EXP/[mmm]/[YYYY], atau kalau menginginkan model proper-case seperti ini: 30912/EXP/Mar/2010, maka tinggal menyesuaikannya sebagai: [XXXXX]/EXP/[Mmm]/[YYYY].

00912/INV/III/10 = [XXXXX]/EXP/[M]/[YY]
Elemen bulan dalam hal ini menggunakan metode bilangan romawi, untuk kasus ini saya memanfaatkan elemen M (dikapitalisasi) satu perulangan. begitu pula dengan elemen tahun (Y), dalam hal ini penomoran yang diinginkan adalah menggunakan model dua digit tahun, karenanya kodifikasi disesuaikan dengan menggunakan dua elemen Y.

30912/INV/30/March/2010 = [XXXXX]/INV/[DD]/[Mmmm]/[YYYY]
Dalam kasus ini, penomoran dokumen yang diinginkan adalah menggunakan elemen dua digit tanggal karenanya format atas dokumen ini menggunakan dua elemen D. Di sisi lain penomoran tersebut menggunakan nama bulan secara penuh dan menggunakan proper-case, karenanya format elemen bulan tersebut disesuaikan dengan menggunakan 4 elemen M secara proper-case [Mmmm]. Sebagai perbandingan lain, jika menginginkan penggunaan nama bulan dalam huruf kapital seperti ini: 30912/INV/EXP/MARCH/2010, maka tentunya tinggal menyesuaikan elemen bulan (M) dalam 4 elemen huruf kapital [MMMM].

Implementasi

Pemecahan yang paling fleksibel atas kasus di atas adalah dengan memanfaatkan metode parsing atas format dokumen yang ada, parameter input dalam hal ini adalah format dokumen, nomor dokumen, serta tanggal. Proses parsing dilakukan dengan cara memisahkan antara elemen penenomoran serta karakter pembentuk, dalam hal ini untuk membedakan antara elemen dan karakter pembentuk dilakukan dengan mengapit elemen dengan dengan menggunakan karakter yang dianggap paling jarang digunakan, dalam hal ini adalah karakter “[" sebagai pembuka elemen dan karakter "]” sebagai penutup. Atas karakter-karakter yang tidak dianggap sebagai elemen langsung kita salin sebagai output, kemudian saat menemukan elemen yang dikenal maka program akan menghitung berapa jumlah karakter elemen yang digunakan serta jumlah kapitalisasinya kemudian menyisipkan dengan nilai yang sesuai atas elemen tersebut. Berikut adalah implementasi kode serta cara penggunaannya:

import datetime as dt

def formatNumber(strfmt, aval, dt):
  '''Format the document number'''
  prd_list = ('I','II','III','IV','V','VI',
      'VII','VIII','IX','X','XI','XII')
  shmonths = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')
  lnmonths = ('January', 'February', 'March', 'April', 'May', 'June',
              'July', 'August', 'September', 'October', 'November', 'December')

  ncount = ntotal = ncapital = 0
  calc_total = False
  ret_str = ""
  last_token = None

  for ch in strfmt:
    token = ch.upper()
    if calc_total:
      if last_token == token:
        ntotal = ntotal+1
        if last_token == ch:
          ncapital = ncapital + 1
      else:
        if last_token == 'X':
          astr = "%.*d" % (ntotal, int(aval))
          ret_str = ret_str + astr[:ntotal]
        elif last_token == 'D':
          astr = "%.*d" % (2, int(dt.day))
          ret_str = ret_str + astr[:2]
        elif last_token == 'M':
          if ntotal in (1, 2, 3):
            if (ntotal == 1) and (ncapital == 1):
              ret_str = ret_str + prd_list[dt.month]
            elif ntotal in (1, 2):
              astr = "%.*d" % (ntotal, int(dt.month))
              ret_str = ret_str + astr[:ntotal]
            else:
              shmon = shmonths[dt.month]
              if ncapital == ntotal:
                smon = shmon.upper()
              elif ncapital == 0:
                smon = shmon.lower()
              ret_str = ret_str + smon
          else:
            shmon = lnmonths[dt.month]
            if ncapital == ntotal:
              smon = shmon.upper()
            elif ncapital == 0:
              smon = shmon.lower()
            ret_str = ret_str + smon
        elif last_token == 'Y':
          if ntotal <= 2:
            astr = "%.*d" % (2, int(dt.year % 100))
            ret_str = ret_str + astr[:2]
          else:
            astr = "%.*d" % (4, int(dt.year))
            ret_str = ret_str + astr[:4]
        ntotal = ncapital = 0
        calc_total = False
    if not calc_total:
      if token == '[':
          ncount = ncount+1
      elif token == ']':
          ncount = ncount-1
      elif token in ('X', 'D', 'M', 'Y'):
        if ncount > 0:
          calc_total = True
          last_token = token
          ntotal = 1
          if last_token == ch:
            ncapital = ncapital + 1
        else:
          ret_str = ret_str+ch
      else:
        ret_str = ret_str+ch
  return ret_str

def_format = "[xxxx]/INV/EXP/[MM]/[YYYY]"
print(formatNumber(def_format, 8540, dt.date.today()))

It is quite hard to start of, mainly because I do not have any windows vista installed on my desktop, nor on my notebook. The only way is trying to analyze the problem from the exception log file he sent to me, then I can find of and start with the main source line where the problem occured:

  InitializeSecurityDescriptor(@Sd,SECURITY_DESCRIPTOR_REVISION);
  SetSecurityDescriptorDacl(@Sd,true,nil,false);
  Sa.nLength := SizeOf(Sa);
  Sa.lpSecurityDescriptor := @Sd;
  Sa.bInheritHandle := true;
  m_Handle := CreateFileMapping(INVALID_HANDLE_VALUE,
                @Sa, PAGE_READWRITE OR SEC_COMMIT,
                0, m_Size, PChar(FileName));

  if m_Handle = 0 then
    raise EMemoryMappedFileException.Create(SCreateError);

Not knowing what I should do with this line since I can not debug it to know it’s behaviour on Vista, I try to search on google and did find some workaround to deal with, but none of them proved to works. Does diabling the UAC (User Access Control) or run the application on Administration mode is the last solution? i hope not, I still believe there were another better way to deal with.

Any suggestion are welcome.

Salah satu solusi yang ditawarkan sebagai pemecahan atas kasus ini adalah dengan memanfaatkan a LDAP sebagai penyedia layanan otentikasi pengguna secara tersentralisir. Dengan memanfaatkan LDAP, manajemen user, password, dan informasi-informasi yang terkait lainnya dapat dilakukan secara tersentralisir, aplikasi hanya menyediakan mapping atas role, dan group yang diijinkan untuk mengakses fitur-fitur tertentu dari aplikasi tersebut. Saat ini ada cukup banyak alternatif perangkat lunak server LDAP yang bisa digunakan:

• Microsoft Actice Directory Service perangkat lunak ini terintegrasi dengan Windows mulai versi 2000 ke atas.
• OpenLDAP Pemain lama, stabil dan terbukti berperforma baik, hanya sayang dukungan binary untuk OS Windows nampaknya dianaktirikan.
• Microsoft ADAM, perangkat lunak Active Directory yang mandiri, ringan, dan memiliki fitur yang cukup untuk memenuhi kebutuhan secara umum.
• OpenDS, salah satu alternatif pilihan server berbasis Java, pada dasarnya saya sangat suka kemudahan yang ditawarkan OpenDS untuk melakukan manajemen pengguna, control panel bawaannya telah memiliki form-form yang sangat memudahkan pengguna tanpa harus dipusingkan terlebih dulu atribut-atribut yang terdapat pada LDAP.
• Apache Directory, perangkat lunak ini sederhananya adalah yang paling saya sukai, karena fitur yang ditawarkanny, dan terlebih karena memiliki Apache Directory Studio, tool di sisi client yang sangat ampuh dalam menangani kompleksitas manajemen LDAP secara mudah. Hanya saja versi yang terbaru dari ApacheDS (1.5.x) masih terbilang belum stabil, namun kendati demikian untuk operasional sehari-hari dalam lingkup internal network, sejauh ini saya tidak menemui masalah apapun.

Di sisi aplikasi client sendiri, dengan memanfaatkan unit ldapsend.pas dari synapse sebagai pustaka pihak ke-tiga, kita bisa membuat rutin untuk melakukan verifikasi atas user dan password secara mudah:

function TfrmMain.VerifyUserAuth(const AServer, APort, AUserName, APassword,
  ABaseDN, AUserRDN, AFilter: string; AAtribs, AReturn: TStrings): boolean;
var
  ALDAPSender: TLDAPSend;
  AUserDN: string;
  AResult: boolean;
  I: integer;
begin
  Result := False;
  AReturn.Clear;
  ALDAPSender := TLDAPSend.Create;
  try
    ALDAPSender.TargetHost := AServer;
    ALDAPSender.TargetPort := APort;
    AUserDN := Format('%s=%s,%s',[AUserRDN, AUserName, ABaseDN]);
    ALDAPSender.UserName := AUserDN;
    ALDAPSender.Password := APassword;
    AResult := ALDAPSender.Login;
    if not AResult then
      raise Exception.Create('Could not establish connection to LDAP server.');
    AResult := ALDAPSender.Bind;
    if not AResult then
      raise Exception.Create('Credential information supplied is not valid.');
    AResult := ALDAPSender.Search(AUserDN, False, AFilter, AAtribs);
    if AResult then
    begin
      for I := 0 to ALDAPSender.SearchResult[0].Attributes.Count-1 do
      begin
        AReturn.Values[
          ALDAPSender.SearchResult[0].
            Attributes[i].AttributeName
          ] := ALDAPSender.SearchResult[0].Attributes[i][0];
      end;
    end;
    Result := AResult;
  finally
    ALDAPSender.Free;
  end;
end;

Contoh pemanfaatan dalam aplikasi:

procedure TfrmMain.btnTestLogin3Click(Sender: TObject);
var
  AAtribs, AReturn: TStrings;
begin
  AAtribs := TStringList.Create;
  AReturn := TStringList.Create;
  try
    AAtribs.Add('displayName');
    AAtribs.Add('mail');
    if VerifyUserAuth('127.0.0.1','389',
                      'jaimy',
                      'password',
                      'ou=users,dc=example,dc=com',
                      'uid',
                      '(objectClass=inetOrgPerson)',
                      AAtribs, AReturn) then
    begin
      ShowMessage(Format('Hallo %s<%s>, anda berhasil login',
        [
          AReturn.Values['displayName'],
          AReturn.Values['mail']
        ]));
    end;
  finally
    AReturn.Free;
    AAtribs.Free;
  end;
end;

Ragam solusi yang terdapat di java sangat menarik dan terlalu sayang untuk tidak dimanfaatkan, namun permasalahannya, bagaimana jika kita sudah memiliki sebuah middleware server yang dibangun dengan delphi? Memportingnya ke java jelas bukanlah sebuah solusi yang mudah karena itu bisa berarti menulis ulang keseluruhan sistem dari awal. Solusi yang paling memungkinkan tentunya adalah menginterfacekan middleware server yang dibuat dengan delphi tersebut dengn Java, dengan kata lain meng-embbed java virtual machine ke dalam middleware server Delphi sehingga memungkinkan kita memanfaatkan java dalam sistem yang kita buat dengan menggunakan Delphi.

Bagaimana Caranya?

Cukup sederhana sebenarnya, komunitas delphi, meskipun tidak sebesar komunitas java, namun tidak pula sekecil yang kita pikirkan. Solusi untuk menginterfacekan Delphi dengan Java dengan memanfaatkan JNI telah tersedia dan bisa dimanfaatkan untuk kebutuhan kita. Matthew Mead telah membuat translasi Java Native Interface Wrapper yang memungkinkan Delphi bisa melakukan interfacing dengan kode-kode yang ditulis dengan java. Yang kita butuhkankan hanyalah mendownload wrapper tersebut.
   

• Download Java Native Interface Wrapper

Kita perlu sedikit melakukan modifikasi pada file JNI.pas, mulai pada baris 89 dengan kode berikut:

  JNI_VERSION_1_5 = JInt($00010005);
  {$EXTERNALSYM JNI_VERSION_1_5}
  JNI_VERSION_1_6 = JInt($00010006);
  {$EXTERNALSYM JNI_VERSION_1_6}

{$DEFINE DYNAMIC_LINKING}

Strukturisasi class yang terdapat dalam wrapper tersebut bisa dikatakan cukup baik, kita hanya perlu memastikan hanya ada satu instance class TJavaVM dalam keseluruhan aplikasi kita. Barangkali akan timbul pertanyaan, middleware umumnya berbasis multithread, dan menggunakan single instance seperti itu tentunya akan beresiko tinggi, atau setidaknya menurunkan performa karena harus melakukan locking dan sinkronisasi setiap akan menggunakannya. Kita tidak perlu kuatir untuk hal ini karena kita tidak akan menggunakan object instance dari TJavaVM secara langsung, melainkan untuk tiap-tiap thread kita membuat satu instance dari class TJNIEnv dengan menggunakan TJavaVM sebagai referer.

Inisialisasi JavaVM

Mari kita lanjutkan dengan membuat inisialisasi TJavaVM pada class utama aplikasi, bisa main class, atau main server object class, bergantung pada bagaimana struktur class yang terdapat dalam middleware yang dibuat.

type
  TServerManager = class(TAbstractLifeCycle)
  ...
  private
    FJavaVM: TJavaVM;
    procedure InitializeVM(FEngine: TJavaVM);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    property JavaVM: TJavaVM read FJavaVM;
  end;

...
const
  CJVM_Path = 'C:\Java\jdk1.6.0_04\jre\bin\client\jvm.dll';

constructor TServerManager.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ...
  FJavaVM := TJavaVM.Create(JNI_VERSION_1_6, CJVM_Path);
end;

destructor TServerManager.Destroy;
begin
  FJavaVM.Free;
  ...
  inherited Destroy;
end;

procedure TServerManager.InitializeVM(FEngine: TJavaVM);
var
  Options: array [0..4] of JavaVMOption;
  VM_args: JavaVMInitArgs;
  Errcode: Integer;
begin
  Options[0].optionString := '-Djava.class.path=.'; // tambahkan library lain pada classpath jika diperlukan
  VM_args.version := JNI_VERSION_1_6;
  VM_args.options := @Options;
  VM_args.nOptions := 1;
  Errcode := FEngine.LoadVM(VM_args);
  if Errcode < 0 then
    Raise Exception.Create(Format('Error loading JavaVM, error code = %d', [Errcode]));
end;

Pastikan method InitializeVM dipanggil hanya sekali setelah object class utama itu di-create, namun jangan menggabungkannya pada constructor TServerEngine karena bisa menyebabkan memory leakage jika penanganan atas itu keliru.

begin
  FServerManager := TServerManager.Create(Self)
  FServerManager.InitializeVM(FServerManager.JavaVM);
end;

Seperti yang telah disebutkan sebelumnya, sebelum kita mulai melakukan invoking method java dari delphi, kita harus membuat terlebih dulu satu buah instance dari class TJNIEnv untuk tiap-tiap process thread dari middleware tersebut dengan menggunakan object instance TJavaVM sebagai referer.

type
  TServerCommandHandler = class(TBaseCommandHandler)
  ...
  private
    FJNIEnv: TJNIEnv;
    FServerManager: TServerManager;

    procedure SetServerManager(AValue: TServerManager);
  public   

    property JNIEnv: TJNIEnv read FJNIEnv;
    property Servermanager: TServerManager read FServerManager write SetServerManager;
  end;

procedure TServerCommandHandler.SetServerManager(AValue: TServerManager);
begin
   if AValue = FServerManager then
      exit;
   if AValue = nil then
   begin
      if Assigned(FJNIEnv) then
          FreeAndNil(FJNIEnv);
   end else
   begin
      if Assigned(FJNIEnv) then
          FreeAndNil(FJNIEnv);
      FJNIEnv := TJNIEnv.Create(AValue.JavaVM.Env);
   end;
   FServerManager := AValue;
end;

Invoking Java Method dari Delphi

Untuk melakukan pemanggilan atas method Java melalui delphi dari process thread tersebut, kita tinggal menggunakan object instance TJNIEnv yang telah dibuat sebelumnya. Implementasi pada bagian ini sangat beragam, dan bisa menjadi sangat kompleks bergantung pada tipikal task yang dikerjakan di sisi middleware yang dibuat, namun contoh yang paling sederhananya adalah sebagai berikut:

var
  Cls: JClass;
  Mid: JMethodID;
  JStr: JString;
begin
  Cls := FJNIEnv.FindClass('FunctionTest');
  if Cls = nil then
    LogAndRaise('Can''t find class: FunctionTest');
  Mid := FJNIEnv.GetStaticMethodID(Cls, 'sayHello', '(Ljava/lang/String;)Ljava/lang/String;');
  if Mid = nil then
    LogAndRaise('Can''t find method: sayHello');

   // Call the static method
  JStr := FJNIEnv.CallStaticObjectMethod(Cls, Mid, ['Hello World']);

  // Convert the returned JString to a Delphi string
  DataMessage.Reply(FJNIEnv.JStringToString(JStr));
end;

Kode java yang akan dipanggil dalam hal ini adalah sebagai berikut:

public class FunctionTest{

  public static String sayHello(String inputHello)
  {
    String hello = "Hello World";
    return hello;
  }
}

  with TForm2.Create(Self) do
  try
    ShowModal;
  finally
    Free;
  end;

Tidak salah sebenarnya, namun proses panggil memanggil seperti ini menjadikan aplikasi menjadi kompleks, karena modul pemanggil sebagai aplikasi utama harus menyertakan pula unit atas modul-modul yang akan dipanggil. Program berskala yang lebih besar semacam dan kompleks akan melibatkan puluhan, ratusan, atau bahkan ribuan modul di dalamnya, apakah untuk program semacam ini semua modul tersebut harus disertakan? tentunya akan lebih baik bila modul-modul itu dapat dipanggil secara dinamis dan otomatis oleh pemanggil dengan mudah. Kita cukup membuat modulnya, meregistrasikannya, dan recompile. Aplikasi utama akan secara otomatis menampilkan modul baru tersebut. :)

Bagaimana Caranya?

Delphi sebagai bahasa yang mendukung OOP menyediakan Class Abstraction yang bisa kita manfaatkan untuk membuat modular sistem secara dinamis. Dalam hal ini kita bisa memulainya dengan membuat class Abstract Module yang akan menjadi class dasar yang digunakan oleh aplikasi utama untuk memanggil modul-modul yang terdapat dalam aplikasi secara keseluruhan.

  TAbstractModule = class(TComponent)
  public
    procedure Execute; virtual; abstract;

    class function ModuleName: string; virtual;
    class function ModuleDesc: string; virtual;
  end;
  TAbstractModuleClass = class of TAbstractModule;

...
...

class function TAbstractModule.ModuleDesc: string;
begin
  Result := 'Undefined';
end;

class function TAbstractModule.ModuleName: string;
begin
  Result := 'Undefined';
end;

Kemudian langkah selanjutnya, setiap modul yang akan dibuat menjadi dinamis harus dibuat sebagai class dan diturunkan dari abstract module di atas.

  TTestModule1 = class(TAbstractModule)
  public
    procedure Execute; override;

    class function ModuleName: string; override;
    class function ModuleDesc: string; override;
  end;

...
...

class function TTestModule1.ModuleDesc: string;
begin
  Result := 'This is a Test Module #1 Description';
end;

class function TTestModule1.ModuleName: string;
begin
  Result := 'Test Module 1';
end;

Selanjutnya jangan lupa, ini bagian terpentingnya, dibagian paling bawah, registerkan setiap modul class yang dibuat pada class registration punyanya delphi.

initialization
  RegisterClass(TTestModule1);

finalization
  UnRegisterClass(TTestModule1);

Sampai di sini apa yang harus dilakukan di sisi modulnya telah selesai, kini tinggal di program utama (Main Form). Ada beberapa hal yang harus dilakukan di sini, yaitu meng-construct list module dan membuat generic event yang akan mencari class yang sesuai saat user memilih modul tersebut.

procedure TfrmMain.CollectModules;
var
  AClassFinder: TClassFinder;
begin
  ListBox1.Clear;
  AClassFinder := TClassFinder.Create(TAbstractModule);
  try
    AClassFinder.GetClasses(EvaluateClass);
  finally
    AClassFinder.Free;
  end;
end;

procedure TfrmMain.EvaluateClass(AClass: TPersistentClass);
begin
  if (AClass.InheritsFrom(TAbstractModule)) and (AClass <> TAbstractModule)  then
  begin
    ListBox1.AddItem(Format('%s - %s',
      [
        TAbstractModuleClass(AClass).ModuleName,
        TAbstractModuleClass(AClass).ModuleDesc
      ]),
      TObject(AClass)
    );
  end;
end;

Nah selesai, dengan trik sederhana ini, kita bisa memanfaatkan fitur-fitur standar yang ada pada delphi untuk membuat aplikasi modular secara dinamis. Jika tertarik dengan demo dan source dari artikel ini, anda bisa mendownloadnya di sini.

#! /usr/bin/python
m = n = 4
printout = lambda x, y: ' %d ' % y if x else ''

for i in range(m*n):
  y = i / 4
  x = i % 4
  print "%d:" % i,
  print printout(y != 0, (y-1) * m + x),
  print printout((x!=(m-1)), y * m + (x + 1)),
  print printout((y!=(n-1)),(y+1) * m + x),
  print printout((x != 0),y * m + (x - 1))

Namun setelah host midleware server-nya mencapai tahapan maturity yang cukup baik, sepertinya ini saat yang cukup tepat untuk melakukan revisit, dan sepertinya bisa dikatakan tulis ulang karena kode yang saya buat sebelumnya banyak yang keliru dalam pemanfaatan Python API functionya. Meskipun belum sempat saya test lebih lanjut, kode dasar ini saya postingkan di sini sebagai alternatif pengarsipan.

Berikut adalah source code DBExpress Wrapper dalam Delphi:

unit dbxapi;

interface

uses
  SysUtils, Classes, DBCommonTypes, SqlExpr, Variants, ECFPythonEngine,
  ecfpyinf, FMTBcd, DB, DBXCommon;

type
  TECFDbxAccess = class(TComponent)
  private
    FConnection: TSQLConnection;
    FQuery: TCustomSQLDataSet;
  public
    constructor Create( AOwner : TComponent ); override;
    destructor  Destroy; override;

    procedure Execute(const SQL: WideString);

    property Connection: TSQLConnection read FConnection;
    property Query: TCustomSQLDataSet read FQuery;
  end;

  TECFDbxConn = class(TPyObject)
  private
    FSQLConn: TECFDbxAccess;

    function getHeaders: PPyObject;
  public
    constructor Create( APythonType : TPythonType ); override;
    destructor  Destroy; override;

    function _SetDriverName( args : PPyObject ) : PPyObject; cdecl;
    function _SetGetDriverFunc( args : PPyObject ) : PPyObject; cdecl;
    function _SetLibraryName( args : PPyObject ) : PPyObject; cdecl;
    function _SetParams( args : PPyObject ) : PPyObject; cdecl;
    function _VendorLib( args : PPyObject ) : PPyObject; cdecl;
    function _beginTrans( args : PPyObject ) : PPyObject; cdecl;
    function _commitTrans( args : PPyObject ) : PPyObject; cdecl;
    function _rollbackTrans( args : PPyObject ) : PPyObject; cdecl;
    function _query( args : PPyObject ) : PPyObject; cdecl;
    function _fetch_array( args : PPyObject ) : PPyObject; cdecl;
    function _close( args : PPyObject ) : PPyObject; cdecl;

    class procedure RegisterMethods( PythonType : TPythonType ); override;
  end;

  TPythonDbxConn = class( TPythonType)
  public
    constructor Create( AOwner : TComponent ); override;
  end;

  TECFDbxAPI = class(TECFPythonModule)
  private
    FPythonDBXConn: TPythonDbxConn;
  public
    function PyGetConnection( pyself, args : PPyObject ) : PPyObject; cdecl;

    procedure RaiseDBXError(const Msg: string);
  public
    constructor Create( AOwner : TComponent ); override;
    destructor  Destroy; override;

    procedure Initialize; override;
    procedure SetupObjectType;
  end;

  procedure CreateComponents( AOwner : TComponent; APyEngine: TPythonEngine );

implementation
uses
  ActiveX;

type
  TProtCustomSQLDataSet = class(TCustomSQLDataSet);

const
  TYPE_STRING	= 1;
  TYPE_BINARY	= 2;
  TYPE_NUMBER	= 3;
  TYPE_DATETIME	= 4;
  TYPE_DECIMAL	= 5;

var
  DbxAPIModule: TECFDbxAPI;

procedure CreateComponents( AOwner : TComponent; APyEngine: TPythonEngine );
begin
  with TECFDbxAPI.Create(AOwner) do
  begin
    Engine := APyEngine;
    SetupObjectType;
  end;
end;

{ TECFDbxAPI }

constructor TECFDbxAPI.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ModuleName := '_dbxapi';
  Name := 'ECFDbxAPI';
  with DocString do
    begin
      Add( 'This module contains several Object Types that' );
      Add( 'will let you work with the DBExpress and access' );
      Add( 'a database in a python DB-API compatible implementation.' );
      Add( '' );
      Add( 'getdbxconn(drv,getdrvfnc,libnm,vlibnm,params) -> Get dbx connection object' );
    end;
  with Errors.Add do
    Name := 'DBXError';
  DbxAPIModule := Self;
end;

destructor TECFDbxAPI.Destroy;
begin
  inherited Destroy;
end;

procedure TECFDbxAPI.Initialize;
begin
  AddDelphiMethod('getdbxconn',
    PyGetConnection,
    'getdbxconn(drv,getdrvfnc,libnm,vlibnm,params) -- get connection object with driver attached '+
    'on it.');
  inherited Initialize;
end;

function TECFDbxAPI.PyGetConnection(pyself, args: PPyObject): PPyObject;
var
  drv,getdrvfnc,libnm,vlibnm,params:PChar;
  AThreadState: PPyThreadState;
begin
  Result := nil;
  with GetPythonEngine do
  begin
    if Assigned(args) and (PyTuple_Size(args) > 0) and
      (PyArg_ParseTuple( args, 'sssss:', [@drv,@getdrvfnc,@libnm,@vlibnm,@params]) <> 0) then
    begin
      Result := FPythonDBXConn.CreateInstance;
      if (Result <> nil) then
      begin
        with TECFDbxConn(PythonToDelphi(Result)).FSQLConn do
        begin
          if Connection.Connected then
            Connection.Close;
          Connection.DriverName := String(drv);
          Connection.GetDriverFunc := String(getdrvfnc);
          Connection.LibraryName := String(libnm);
          Connection.VendorLib := String(vlibnm);
          Connection.Params.Text := String(params);
          Connection.LoginPrompt := False;
          try
            AThreadState := PyEval_SaveThread;
            try
              Connection.Open;
            finally
              PyEval_RestoreThread(AThreadState);
            end;
          except
            on E:Exception do
              begin
                Py_XDECREF(Result);
                RaiseDBXError(E.Message);
                Result := nil;
              end;
          end;
        end;
      end;
    end else
      RaiseDBXError('Connection could not be established');
  end;
end;

procedure TECFDbxAPI.RaiseDBXError(const Msg: string);
begin
  RaiseError('DBXError', Msg);
end;

procedure TECFDbxAPI.SetupObjectType;
begin
  FPythonDBXConn := TPythonDbxConn.Create(Self);
end;

{ TECFDbxAccess }

constructor TECFDbxAccess.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  CoInitialize(nil);
  FConnection             := TSQLConnection.Create(Self);
  FConnection.LoginPrompt := False;
  FQuery                  := TCustomSQLDataSet.Create(Self);
  FQuery.SQLConnection    := FConnection;
end;

destructor TECFDbxAccess.Destroy;
begin
  FQuery.Free;
  FConnection.Free;
  inherited Destroy;
end;

procedure TECFDbxAccess.Execute(const SQL: WideString);
begin
  FConnection.ConnectionState := csStateExecuting;
  try
    CoInitialize(nil);
    FQuery.Active := False;
    TProtCustomSQLDataSet(FQuery).CommandText := SQL;
    FQuery.Active := True;
  finally
    FConnection.ConnectionState := csStateOpen;
  end;
end;

{ TPythonDbxConn }

constructor TPythonDbxConn.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  if AOwner is TECFPythonModule then
  begin
    Module := TECFPythonModule(AOwner);
    Engine := Module.Engine;
  end;
  Name     := 'typeDbxConn';
  TypeName := 'DBXConn';
  PyObjectClass := TECFDbxConn;
  GenerateCreateFunction := False;
end;

{ TECFDbxConn }

constructor TECFDbxConn.Create(APythonType: TPythonType);
begin
  inherited Create(APythonType);
  FSQLConn := TECFDbxAccess.Create(nil);
end;

destructor TECFDbxConn.Destroy;
begin
  FSQLConn.Free;
  inherited Destroy;
end;

function TECFDbxConn.getHeaders: PPyObject;
var
  APyHeader, APyColumn: PPyObject;
  AColType: integer;
  AColName: string;
  I: Integer;
begin
  with GetPythonEngine do
  begin
    APyHeader := PyTuple_New(FSQLConn.Query.FieldCount);
    if APyHeader = nil then
      CheckError(False);
    for I := 0 to FSQLConn.Query.FieldCount - 1 do
    begin
      AColType := 0;
      case FSQLConn.Query.Fields[i].DataType of
        ftString, ftFixedChar, ftWideString, // 19..24
        ftFixedWideChar, ftWideMemo
            : AColType := TYPE_STRING;
        ftBlob, ftMemo, ftGraphic, ftFmtMemo, // 12..18
        ftBytes, ftVarBytes, ftADT, ftArray, ftTypedBinary
            : AColType := TYPE_BINARY;
        ftSmallint, ftInteger, ftWord, // 0..4
        ftBoolean, ftAutoInc, ftLargeint
            : AColType := TYPE_NUMBER;
        ftDate, ftTime, ftDateTime, // 5..11
        ftTimeStamp
            : AColType := TYPE_DATETIME;
        ftFloat, ftCurrency, ftBCD, ftFMTBcd
            : AColType := TYPE_DECIMAL;
      end;
      AColName := FSQLConn.Query.Fields[i].FieldName;
      APyColumn := PyTuple_New(2);
      if APyColumn = nil then
      begin
        Py_XDECREF(APyHeader);
        CheckError(False);
      end;
      PyTuple_SetItem(APyColumn, 0, PyString_FromString(PChar(AColName)));
      PyTuple_SetItem(APyColumn, 1, PyLong_FromLong(AColType));
      PyTuple_SetItem(APyHeader, I, APyColumn);
    end;
    Result := APyHeader;
  end;
end;

class procedure TECFDbxConn.RegisterMethods(PythonType: TPythonType);
begin
  inherited RegisterMethods(PythonType);
  with PythonType do
  begin
    AddMethod( 'driverName',  @TECFDbxConn._SetDriverName,
      'DBXConn.driverName(drvname) -> None' );
    AddMethod( 'getDriverFunc',  @TECFDbxConn._SetGetDriverFunc,
      'DBXConn.getDriverFunc(getdrvfunc) -> None' );
    AddMethod( 'libraryName',  @TECFDbxConn._SetLibraryName,
      'DBXConn.libraryName(libname) -> None' );
    AddMethod( 'setParam',  @TECFDbxConn._SetParams,
      'DBXConn.setParam(name, value) -> None' );
    AddMethod( 'vendorLib',  @TECFDbxConn._VendorLib,
      'DBXConn.vendorLib(vdrlib) -> None' );
    AddMethod( 'beginTrans',  @TECFDbxConn._beginTrans,
      'DBXConn.beginTrans() -> TransactionID' );
    AddMethod( 'commit',  @TECFDbxConn._commitTrans,
      'DBXConn.commit(TransactionID) -> None' );
    AddMethod( 'rollback',  @TECFDbxConn._rollbackTrans,
      'DBXConn.rollback(TransactionID) -> None' );
    AddMethod( 'query',  @TECFDbxConn._query,
      'DBXConn.query(SQL) -> affected rows' );
    AddMethod( 'fetch_array',  @TECFDbxConn._fetch_array,
      'DBXConn._fetch_array() -> array of result' );
    AddMethod( 'close',  @TECFDbxConn._close,
      'DBXConn.close) -> None' );
  end;
end;

function TECFDbxConn._beginTrans(args: PPyObject): PPyObject;
var
  AThreadState: PPyThreadState;
  ATransactionID: Integer;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      try
        AThreadState := PyEval_SaveThread;
        try
          ATransactionID := Integer(FSQLConn.Connection.BeginTransaction);
        finally
          PyEval_RestoreThread(AThreadState);
        end;
        Result := PyLong_FromLong(ATransactionID);
      except
        on E:Exception do
          begin
            DbxAPIModule.RaiseDBXError(E.Message);
          end;
      end;
    end;
  end;
end;

function TECFDbxConn._close(args: PPyObject): PPyObject;
var
  AThreadState: PPyThreadState;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      try
        AThreadState := PyEval_SaveThread;
        try
          if FSQLConn.Query.Active then
            FSQLConn.Query.Close;
          if FSQLConn.Connection.Connected then
            FSQLConn.Connection.Close;
        finally
          PyEval_RestoreThread(AThreadState);
        end;
        Result := ReturnNone;
      except
        on E:Exception do
          begin
            DbxAPIModule.RaiseDBXError(E.Message);
          end;
      end;
    end;
  end;
end;

function TECFDbxConn._commitTrans(args: PPyObject): PPyObject;
var
  AThreadState: PPyThreadState;
  ATransactionID: Integer;
  ATrans: TDBXTransaction;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      if (PyArg_ParseTuple( args, 'L:DBXConn.commit', [@ATransactionID] ) <> 0) then
      begin
        ATrans := TDBXTransaction(Ptr(ATransactionID));
        if ATrans = nil then
          DbxAPIModule.RaiseDBXError('Invalid Transaction ID')
        else
        begin
          try
            AThreadState := PyEval_SaveThread;
            try
              FSQLConn.Connection.CommitFreeAndNil(ATrans);
            finally
              PyEval_RestoreThread(AThreadState);
            end;
            Result := ReturnNone;
          except
            on E:Exception do
              begin
                DbxAPIModule.RaiseDBXError(E.Message);
              end;
          end;
        end;
      end else
      begin
        DbxAPIModule.RaiseDBXError('TransactionID should be specified');
        Result := nil;
      end;
    end;
  end;
end;

function TECFDbxConn._fetch_array(args: PPyObject): PPyObject;
var
  APyResult, APyHeader, APyRecord, APyRecordLst, APyRecordTuple: PPyObject;
  AThreadState: PPyThreadState;
  ACount: Int64;
  I: integer;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      try
        APyResult := PyTuple_New(3);
        if APyResult = nil then
          CheckError(False);
        try
          APyHeader := getHeaders;
          PyTuple_SetItem(APyResult, 0, APyHeader);
        except
          Py_XDECREF(APyResult);
          raise;
        end;
        ACount := 0;
        APyRecordLst := PyList_New(0);
        while not FSQLConn.Query.Eof do
        begin
          APyRecord := PyTuple_New(FSQLConn.Query.FieldCount);
          if APyRecord = nil then
          begin
            Py_XDECREF(APyRecordLst);
            Py_XDECREF(APyResult);
            CheckError(False);
          end;
          for i := 0 to FSQLConn.Query.FieldCount - 1 do
            PyTuple_SetItem(APyRecord, i, VariantAsPyObject(FSQLConn.Query.Fields[i].Value));
          PyList_Append(APyRecordLst, APyRecord);
          Inc(ACount);
          AThreadState := PyEval_SaveThread;
          FSQLConn.Query.Next;
          PyEval_RestoreThread(AThreadState);
        end;
        APyRecordTuple := PyList_AsTuple(APyRecordLst);
        Py_XDECREF(APyRecordLst);
        if APyRecordTuple = nil then
        begin
          Py_XDECREF(APyResult);
          CheckError(False);
        end;
        PyTuple_SetItem(APyResult, 1, PyLong_FromLong(ACount));
        PyTuple_SetItem(APyResult, 2, APyRecordTuple);
        Result := APyResult;
      except
        on E:Exception do
          begin
            DbxAPIModule.RaiseDBXError(E.Message);
          end;
      end;
    end;
  end;
end;

function TECFDbxConn._query(args: PPyObject): PPyObject;
var
  AThreadState: PPyThreadState;
  ASQL: PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      if (PyArg_ParseTuple( args, 's:DBXConn.query', [@ASQL] ) <> 0) then
      begin
        try
          AThreadState := PyEval_SaveThread;
          try
            FSQLConn.Execute(String(ASQL));
          finally
            PyEval_RestoreThread(AThreadState);
          end;
          // Result := PyLong_FromLong(TProtCustomSQLDataSet(FSQLConn.Query).RowsAffected);
          Result := PyLong_FromLong(1);
        except
          on E:Exception do
            begin
              DbxAPIModule.RaiseDBXError(E.Message);
            end;
        end;
      end else
      begin
        DbxAPIModule.RaiseDBXError('TransactionID should be specified');
        Result := nil;
      end;
    end;
  end;
end;

function TECFDbxConn._rollbackTrans(args: PPyObject): PPyObject;
var
  AThreadState: PPyThreadState;
  ATransactionID: Integer;
  ATrans: TDBXTransaction;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    Result := nil;
    if not FSQLConn.Connection.Connected then
      DbxAPIModule.RaiseDBXError('Not connected to the database')
    else
    begin
      if (PyArg_ParseTuple( args, 'L:DBXConn.rollback', [@ATransactionID] ) <> 0) then
      begin
        ATrans := TDBXTransaction(Ptr(ATransactionID));
        if ATrans = nil then
          DbxAPIModule.RaiseDBXError('Invalid Transaction ID')
        else
        begin
          try
            AThreadState := PyEval_SaveThread;
            try
              FSQLConn.Connection.RollbackFreeAndNil(ATrans);
            finally
              PyEval_RestoreThread(AThreadState);
            end;
            Result := ReturnNone;
          except
            on E:Exception do
              begin
                DbxAPIModule.RaiseDBXError(E.Message);
              end;
          end;
        end;
      end else
      begin
        DbxAPIModule.RaiseDBXError('TransactionID should be specified');
        Result := nil;
      end;
    end;
  end;
end;

function TECFDbxConn._SetDriverName(args: PPyObject): PPyObject;
var
  AValue : PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    if (PyArg_ParseTuple( args, 's:DBXConn.driverName', [@AValue] ) <> 0) then
    begin
      FSQLConn.Connection.DriverName := String(AValue);
      Result := ReturnNone;
    end else
    begin
      DbxAPIModule.RaiseDBXError('Driver name should be specified');
      Result := nil;
    end;
  end;
end;

function TECFDbxConn._SetGetDriverFunc(args: PPyObject): PPyObject;
var
  AValue : PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    if (PyArg_ParseTuple( args, 's:DBXConn.getDriverFunc', [@AValue] ) <> 0) then
    begin
      FSQLConn.Connection.GetDriverFunc := String(AValue);
      Result := ReturnNone;
    end else
    begin
      DbxAPIModule.RaiseDBXError('GetDriverFunction name should be specified');
      Result := nil;
    end;
  end;
end;

function TECFDbxConn._SetLibraryName(args: PPyObject): PPyObject;
var
  AValue : PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    if (PyArg_ParseTuple( args, 's:DBXConn.libraryName', [@AValue] ) <> 0) then
    begin
      FSQLConn.Connection.LibraryName := String(AValue);
      Result := ReturnNone;
    end else
    begin
      DbxAPIModule.RaiseDBXError('Library name should be specified');
      Result := nil;
    end;
  end;
end;

function TECFDbxConn._SetParams(args: PPyObject): PPyObject;
var
  AKey, AValue : PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    if (PyArg_ParseTuple( args, 'ss:DBXConn.setParam', [@AKey, @AValue] ) <> 0) then
    begin
      FSQLConn.Connection.Params.Add(Format('%s=%s', [String(AKey), String(AValue)]));
      Result := ReturnNone;
    end else
    begin
      DbxAPIModule.RaiseDBXError('Parameter name, and value should be specified');
      Result := nil;
    end;
  end;
end;

function TECFDbxConn._VendorLib(args: PPyObject): PPyObject;
var
  AValue : PChar;
begin
  with GetPythonEngine do
  begin
    Adjust(@Self);
    if (PyArg_ParseTuple( args, 's:DBXConn.vendorLib', [@AValue] ) <> 0) then
    begin
      FSQLConn.Connection.VendorLib := String(AValue);
      Result := ReturnNone;
    end else
    begin
      DbxAPIModule.RaiseDBXError('Vendor Library name should be specified');
      Result := nil;
    end;
  end;
end;

end.

Sementara Python DBExpress API Wrappernya adalah sebagai berikut:

__author__ = "Jaimy Azle"
__version__ = '0.0.1'

import _dbxapi
import types
import string
import time
import datetime

# compliant with DB SIG 2.0
apilevel = '2.0'

# module may be shared, but not connections
threadsafety = 1

# this module use extended python format codes
paramstyle = 'pyformat'

class DBAPITypeObject:
  def __init__(self,*values):
    self.values = values
  def __cmp__(self,other):
    if other in self.values:
      return 0
    if other < self.values:
      return 1
    else:
      return -1

STRING = DBAPITypeObject(1)
BINARY = DBAPITypeObject(2)
NUMBER = DBAPITypeObject(3)
DATETIME = DBAPITypeObject(4)
DECIMAL = DBAPITypeObject(5)

class Warning(StandardError):
  pass

class Error(StandardError):
  pass

class InterfaceError(Error):
  pass

class DatabaseError(Error):
  pass

class DataError(DatabaseError):
  pass

class OperationalError(DatabaseError):
  pass

class IntegrityError(DatabaseError):
  pass

class InternalError(DatabaseError):
  pass

class ProgrammingError(DatabaseError):
  pass

class NotSupportedError(DatabaseError):
  pass

### cursor object

class pydbxCursor:

  def __init__(self, src):
    self.__source = src
    self.description = None
    self.rowcount = -1
    self.arraysize = 1
    self._result = []
    self.__fetchpos = 0

  def close(self):
    self.__source = None
    self.description = None
    self.result = []
    self.rowcount = -1

  def execute(self, operation, params = None):
    # "The parameters may also be specified as list of
    # tuples to e.g. insert multiple rows in a single
    # operation, but this kind of usage is depreciated:
    if params and type(params) == types.ListType and \
          type(params[0]) == types.TupleType:
      self.executemany(operation, params)
    else:
      # not a list of tuples
      self.executemany(operation, (params,))

  def executemany(self, operation, param_seq):
    self.description = None
    self.rowcount = -1
    self.__fetchpos = 0

    # first try to execute all queries
    totrows = 0
    sql = ""
    try:
      for params in param_seq:
        if params != None:
          sql = _quoteparams(operation, params)
        else:
          sql = operation
        # print sql
        ret = self.__source.query(sql)
        if ret == 1:
          self._result = self.__source.fetch_array()
          totrows = totrows + self._result[1]
        else:
            self._result = None
            raise DatabaseError, "error: %s" % self.__source.errmsg()
    except:
      raise DatabaseError, "internal error: %s" % self.__source.errmsg()

    # then initialize result raw count and description
    self.description = None
    self.rowcount = self._result[1]

  def fetchone(self):
    ret = self.fetchmany(1)
    if ret: return ret[0]
    else: return None

  def fetchall(self):
    return self._result[2][self.__fetchpos:]

  def fetchmany(self, size = None, keep = 1):
    if size == None:
      size = self.arraysize
    if keep == 1:
      self.arraysize = size
    res = self._result
    if res[1]==self.__fetchpos:
        return []
    reslen = len(res[2][self.__fetchpos:])
    if reslen < size:
        size = res[1]
    ret = res[2][self.__fetchpos:self.__fetchpos+size]
    self.__fetchpos = self.__fetchpos + size
    return ret

  def setinputsizes(self, sizes):
    pass

  def setoutputsize(self, size, col = 0):
    pass

def _quote(x):
  if type(x) == types.StringType:
    x = "'" + string.replace(str(x), "'", "''") + "'"
  elif type(x) in (types.IntType, types.LongType, types.FloatType):
    pass
  elif x is None:
    x = 'NULL'
  # datetime quoting
  # described under "Writing International Transact-SQL Statements" in BOL
  # beware the order: isinstance(x,datetime.date)=True if x is
  # datetime.datetime ! Also round x.microsecond to milliseconds,
  # otherwise we get Msg 241, Level 16, State 1: Syntax error
  elif isinstance(x, datetime.datetime):
    x = "{ts '%04d-%02d-%02d %02d:%02d:%02d.%s'}" % \
      (x.year,x.month, x.day,
      x.hour, x.minute, x.second, x.microsecond / 1000)
  elif isinstance(x, datetime.date):
    x = "{d '%04d-%02d-%02d'}" % (x.year, x.month, x.day)
  # alternative quoting by Luciano Pacheco
  #elif hasattr(x, 'timetuple'):
  # x = time.strftime('\'%Y%m%d %H:%M:%S\'', x.timetuple())
  else:
    #print "didn't like " + x + " " + str(type(x))
    raise InterfaceError, 'do not know how to handle type %s' % type(x)

  return x

def _quoteparams(s, params):
  if hasattr(params, 'has_key'):
    x = {}
    for k, v in params.items():
      x[k] = _quote(v)
    params = x
  else:
    params = tuple(map(_quote, params))
  return s % params

### connection object

class pydbxCnx:

  def __init__(self, cnx):
    self.__cnx = cnx
    self.transid = None
    try:
      transid = self.__cnx.beginTrans()
      self.__cnx.commit(transid)
    except:
      raise OperationalError, "invalid connection."

  def close(self):
    if self.__cnx == None:
      raise OperationalError, "invalid connection."
    self.__cnx.close()
    self.__cnx = None

  def commit(self):
    if self.__cnx == None:
      raise OperationalError, "invalid connection."
    try:
      if self.transid:
        self.__cnx.commit(self.transid)
      self.transid = self.__cnx.beginTrans()
    except:
      raise OperationalError, "can't commit."

  def rollback(self):
    if self.__cnx == None:
      raise OperationalError, "invalid connection."
    try:
      if self.transid:
        self.__cnx.rollback(self.transid)
      self.transid = self.__cnx.beginTrans()
    except:
      raise OperationalError, "can't rollback."

  def cursor(self):
    if self.__cnx == None:
      raise OperationalError, "invalid connection."
    try:
      return pydbxCursor(self.__cnx)
    except:
      raise OperationalError, "invalid connection."

# connects to a database
def connect(dsn = None, drv="", getdrvfnc="", libnm="", vlibnm=""):
  # open the connection
  dbdsn = dsn.strip()
  if dbdsn != '':
    dbdict = dict([x.split('=') for x in dsn.split(';')])
    dbdrv = dbdict.pop('DriverName') if dbdict.has_key('DriverName') else drv
    dbgetdrvfnc = dbdict.pop('GetDriverFunc') if dbdict.has_key('GetDriverFunc') else getdrvfnc
    dblibnm = dbdict.pop('LibraryName') if dbdict.has_key('LibraryName') else libnm
    dbvlibnm = dbdict.pop('VendorLibName') if dbdict.has_key('VendorLibName') else vlibnm
    dbdsn = '\n'.join(['%s=%s' % (key, value) for key, value in dbdict.iteritems()])
  else:
    dbdrv = drv
    dbgetdrvfnc = getdrvfnc
    dblibnm = libnm
    dbvlibnm = vlibnm
  con = _dbxapi.getdbxconn(dbdrv, dbgetdrvfnc, dblibnm, dbvlibnm, dbdsn)
  return pydbxCnx(con)

Seberapa begitu menarikkah Jython ini dibanding CPython? Perlu diketahui, CPython saat ini memiliki kelemahan jika digunakan dalam mesin-mesin berbasis multi-core karena keberadaan GIL membuatnya secara internal hanya satu thread yang aktif dieksekusi (meski sebenarnya ada beberapa thread yang berjalan bersamaan), akibatnya tentu saja hanya 1 CPU yang bisa termanfaatkan. Sebenarnya hal ini bisa sedikit banyak diminimalisir dengan memporting kode-kode yang bersifat kritikal ke dalam extenstion module yang dibuat dengan native language, namun besar kecilnya manfaat sangat bergantung pada bagaimana model kerja kode dalam python yang dieksekusi, begitu juga dengan membuat process instance, dan beberapa solusi lainnya. Saya tidak ingin panjang lebar membahas lebih jauh tentang ini, Guido punya alasan yang kuat dan benar yang mendasari kenapa GIL tetap harus dipertahankan setidaknya di Python300 nanti.

Jython dalam hal ini menawarkan fitur yang menjadi keterbatasan CPython saat ini, mendukung multithread dengan memanfaatkan fitur threading dalam JVM dan mentransformasi python code menjadi java byte code sehingga secara logika tingkat performanya lebih kurang setara seperti halnya kode Java aslinya. Namun demikian, tidak berarti Jython berada di atas segala-galanya atas CPython, karena dikembangkan dengan menggunakan Java sebagai basis, otomatis memiliki kelemahan atas kompatibilitas dengan extension module yang banyak menggunakan native language sebagai pendukungnya.

Sejauh ini implementasi yang saya gunakan dengan memanfaatkan CPython sudah cukup memuaskan, skalabilitas implementasi masih bisa dieksplorasi secara lebih jauh seiring dengan masih adanya opsi-opsi yang bisa dipilih terkait dengan isue ini, namun demikian Jython tetap menarik untuk dieksplorasi, sebagai alternatif paling akhir apabila memang tidak ada lagi pilihan untuk itu guna meningkatkan skalabilitas platform system yang ada saat ini.

Sudah cukup lama sebenarnya saya mengevaluasi RDBMS ini, tertarik dengan fitur-fitur yang ditawarkannya sebagai high-end database system untuk dijadikan alternatif pilihan RDBMS yang disupport dalam platform yang saya kembangkan. Permasalahannya tinggal satu sebenarnya, namun justru itulah yang paling menyebalkan, python wrapper untuk akses database secara remote masih terbilang immature, sangat buggy. Hanya dalam hitungan menit setelah application server utama dijalankan, ia membuat crash system secara keseluruhan, karena memory corrupt yang menyebabkan python garbage collection tidak bisa menjalankan fungsinya secara normal.

Tertarik dengan itu, saya mencoba menelaah source code yang ada, ada cukup banyak hal yang terasa aneh dalam source code tersebut yang membuat saya mengira-ngira, apakah developernya menggunakan python versi debug-mode saat menulis driver tersebut? source code tersebut banyak sekali menggunakan API function PyDict_SetItem, dan PyDict_GetItem dan cara menghandle reference count dengan cara berbeda dari yang umum dilakukan, bahkan pada internal CPython source-code-nya sendiri.

Saya mencoba untuk sedikit merubah internal source code driver tersebut, membenarkan bagian-bagian yang saya curigai keliru, recompile dan test, namun hasilnya masih nihil, sepertinya belum mencapai inti permasalahan yang sebenarnya, dan butuh waktu lebih untuk memeriksa alur kerja driver tersebut secara lebih detil. Sayangnya untuk meluangkan waktu secara khusus untuk itu, saat ini masih terbilang mahal, observasi yang saya coba lakukan kemudian beralih kepada kode-kode yang saya tulis, memastikannya bahwa letak permasalahan tersebut bukan di sisi saya, melakukan testing dengan RDBMS lain yang lebih dulu disupport, dan hasilnya server platform saya bisa jalan mulus berhari-hari dari awal hinga akhir ia dishutdown tanpa masalah, simpulan saya memang driver tersebut saat ini masih belum stabil.

Sayang sekali sebenarnya, RDBMS yang terbilang bagus itu ternyata masih belum bisa masuk dalam alternatif pilihan, mungkin suatu saat nanti saya akan revisit kembali.

Namun tentu saja unicode bukan satu-satunya fitur utama, ada banyak fitur lainnya yang cukup menarik dan sangat bernilai, seperti paralel processing library untuk mensupport multicore CPU, DataSnap framework, arsitektur COM dan ActiveX yang diperbarui, dan banyak hal lainnya lagi. :)

sumber:
1. Here Comes Tiburon
2. Unicode database support in Tiburon for Delphi and C++