JPH06103126A - 動的バッファ管理装置および方法 - Google Patents

Abstract

(57)【要約】 【目的】 データベースサーバを拡張する。 【構成】 通信バッファからのデータ構造体を再構成す
るプロセスでの動的メモリ割振りとメモリコピーを改良
して、データベースサーバを拡張する方法、システム、
およびプロセス。

Description

【発明の詳細な説明】

【０００１】

【産業上の利用分野】本発明は、データベース処理の改
良に関し、特に、動的にバッファリングしてデータベー
スへの遠隔アクセスを拡張することに関する。

【０００２】なお、本明細書の記述は本件出願の優先権
の基礎たる米国特許出願第０７／９２３，６３４号の明
細書の記載に基づくものであって、当該米国特許出願の
番号を参照することによって当該米国特許出願の明細書
の記載内容が本明細書の一部分を構成するものとする。

【０００３】

【従来の技術】データベースへの遠隔アクセスをシステ
ム管理するということは、種々の論文および特許の主題
になっている。例えば、米国特許第 5,014,221号には、
アービトレートされたクライアントにアクセスするプリ
ントサーバが開示されている。米国特許第 4,511,964号
には、動的構造体の割り振り、拡張、および割り振り解
除をサーブする記憶制御装置に対して動的記憶マッピン
グを行うことが開示されている。米国特許第 5,025,491
号には、関連する複数のサーバステーションを有する通
信ネットワークであって、コンピュータアルゴリズムに
より判定されるサーバアドレスを有する通信ネットワー
クが開示されている。しかし、これら従来例には、本発
明に係る拡張されたデータベースサーバは開示されてい
ない。

【０００４】従って、本発明の目的は、動的バッファリ
ングを行ってデータベースサーバを拡張することにあ
る。

【０００５】

【課題を解決するための手段】これらの目的および他の
目的を達成するため、本発明は、第２コンピュータのデ
ータベースの情報にアクセスする際に用いるため、第１
コンピュータのメモリでデータ構造体を構成し、メモリ
要件データ構造体を第１コンピュータのデータベースか
ら獲得し、通信バッファを構成する。通信バッファはメ
モリ要件データ構造体を含むとともに、データ構造体の
内容を含むデータベースからの情報を含む。

【０００６】動的バッファは、単一の通信バッファに収
まらないデータ構造体情報をハンドルする能力を参照す
る。従って、単一通信バッファがその伝送に適応しない
場合は、別の情報を含む別の通信バッファが構成され
る。その通信バッファは第２コンピュータに伝送され、
その第２コンピュータにて、通信バッファは受信され分
析され、第２コンピュータで必要とするメモリを判定
し、そのデータ構造体を１つ以上の通信バッファに適応
させる。その後、第２コンピュータは、次の場合に、連
続するメモリを割り振る。すなわち、記憶コピーオーバ
ヘッドを増大させることなく、割り振られた連続するメ
モリに、受信されたデータベースが直接入れられるよう
に、そのデータベースが１つの通信バッファに収めるこ
とができず、しかも、通信バッファの位置を動的に調整
する場合に、連続するメモリを割り振る。

【０００７】メモリ要件が通信バッファのサイズを超え
る場合、サーバはデータ構造体全体を収めることができ
るバッファを割り振る。その通信バッファをそのバッフ
ァにコピーする代わりに、そのデータ構造体が割り振ら
れたバッファのアドレスにポインタが割り当てられる。
そして、そのポインタは、受信されたデータが直接バッ
ファに入られるように動的に調整される。全データが受
信された後は、そのバッファのポインタを調整し、エン
ジンデータ構造体を再構成する。

【０００８】

【実施例】以下、図面を参照して本発明の実施例を詳細
に説明する。

【０００９】本発明は、IBM Corporation のIBM PS/2コ
ンピュータ上に駐在するオペレーティングシステムのコ
ンテキストで実施するのが好ましい。代表的なハードウ
ェア環境を図１に示す。図１はワークステーションの典
型的なハードウェア構成を示す。このワークステーショ
ンは慣用のマイクロプロセッサのような中央処理装置１
０を有する。他の多数の装置がシステムバス１２を介し
て相互接続されている。図１に示すワークステーション
は、RAM(random access memory) １４と、ROM(read onl
y memory) １６と、I/O アダプタ１８とを含む。I/O ア
ダプタ１８はディスク装置２０のような周辺装置をバス
に接続する。また、図１に示すワークステーションは、
キーボード２４を接続するためのユーザインタフェース
アダプタ２２、スピーカ２８、マイクロフォン３２、お
よび／または他のユーザインタフェース装置を含む。他
のユーザインタフェース装置はバスに対するものであっ
て、図示しないタッチスクリーン装置のようなものであ
る。さらに、図１に示すワークステーションは、ワーク
ステーションをデータ処理ネットワークに接続するため
の通信アダプタ３４と、バスをディスプレイ装置３８に
接続するためのディスプレイアダプタ３６を含む。ワー
クステーションには、OS/2オペレーティングシステム
と、ツールキットとしての（本発明を構成する）コンピ
ュータソフトウェアとが駐在している。

【００１０】リレーショナルデータベースに遠隔アクセ
スするため、私用プロトコルがIBMOS/2 1.3 Extended E
dition(EE) オペレーティングシステムにインプリメン
トされた。そのプロトコルは２つのIBM 出版物に詳細に
説明されている。1. Distributed Relational Database
Architecture Reference, Auguast 1990, IBM, SC26-4
651; 2. Distributed Data Management(DDM) Architect
ure Reference, Auguast 1990, IBM, SC21-9526.パフォ
ーマンス試験により、データベースデータ構造体を再構
成するプロセス間のメモリ割振り、メモリコピーに関す
る問題が明らかになった。

【００１１】本発明により、遠隔プロトコルに対するサ
ーバメモリ割振りの効率的な設計が開示されている。そ
のプロトコルはOS/2 Extended Services(ES) 1.0 Remot
e Database Serviceのために設計されている。本発明に
係るシステムはデータ構造体を再構成するために別の記
憶装置を割り振ることなく、通信バッファを用いる。本
発明に係るシステムは、サーバに対するメモリ要件を削
減し、メモリコピーのコストを軽減する。

【００１２】現遠隔プロトコルは、OS/2 1.3 Extended
Edition(EE) の以前の設計と比較して、スループットが
最高５６％までスピードアップされ、エンドユーザのレ
スポンスタイムが３６％もスピードアップされた。SQLJ
RA遠隔プロトコルは、同様に構成された同種の環境のク
ライアントまたはサーバのいずれかで構成されたデータ
構造体をレバレッジ(leverage)する。そのため、データ
構造体の基礎となるものは、変更ステップを必要とせ
ず、直接受け渡しされる。

【００１３】クライアントでは、データストリームコン
ストラクタはデータ構造体からデータストリームを構成
する。そのデータ構造体がポインタを含む場合は、ポイ
ンタにより指示される実際のデータは、データストリー
ムに置かれる。サーバのデータストリームコンストラク
タは、クライアントから受信されたデータストリングに
従ってデータ構造体を作成する。サーバでエンジンデー
タ構造体を再構成するので、データ構造体のためにサー
バはメモリを割り振る必要はない。本発明の目的は、デ
ータ構造体を再構成するために、メモリをどのように効
率よく割り振るかという点にある。

【００１４】OS/2 ES 1.0データベースマネージャで
は、クライアントとサーバは自分自身の通信バッファを
有し、その通信バッファに、送信された情報および受信
された情報をストアする。その通信バッファのサイズは
データベース構成ファイルのブロックサイズにより決定
される。その通信バッファの最小サイズは４Ｋである。
リクエスタ(requester) はデータを通信バッファに置
き、通信ルーチンを呼び出し、実際にそのデータを送信
する。そのサーバは自分自身の通信バッファからデータ
を受信する。

【００１５】クライアントがエンジンデータ構造体を通
信バッファに置く前に、そのクライアントは、まず、デ
ータベースデータ構造体により必要とされた全メモリを
計算する。データベース構造体はJRA 制御構造体と、入
力SQLDA と、出力SQLDA およびSQLCA を含む。メモリ要
件情報は通信バッファに入れられることになる。そし
て、クライアントは制御構造体を通信バッファにコピー
する。通信バッファが一杯にされた場合、クライアント
は通信ルーチンを呼び出し、そのバッファをサーバに送
信する。

【００１６】そして、サーバは通信ルーチンを呼び出
し、データを受信する。クライアントにより送信された
データは、サーバの通信バッファ内に存在することにな
る。クライアントはメモリ要件情報を通信バッファにま
ず入れるので、サーバは受信された第１バッファでメモ
リ要件情報を受信することになる。そして、サーバはこ
の情報を用いて、データ構造体に対してメモリを割り振
ることになる。

【００１７】エンジンデータ構造体により必要とされる
メモリをＭとすると、通信バッファのサイズはＢであ
り、セグメントのサイズはＳである。セグメントは最大
仮想メモリであり、各メモリ割振り呼び出しに対して割
り振ることができる仮想メモリである。例えば、１６ビ
ットOS/2の最大セグメントサイズは６４Ｋである。ま
ず、エンジンデータ構造体により必要されるメモリ
（Ｍ）が通信バッファのサイズ（Ｂ）未満である場合、
余分なメモリは必要ではない。我々はこれらのデータ構
造体をそのままで受け渡しするので、通信バッファを利
用して、エンジンデータ構造体を再構成することができ
る。クライアントは各データ構造体の開始点を位置指定
し、新しいアドレスをSQLJRAのポインタフィールドに割
り当てる。

【００１８】図２は遠隔データベース要求に対する情報
のフローの一例を示す。まず、データベースランタイム
API ルーチン２００は、ユーザSQL 要求から、データベ
ースエンジンデータ構造体を作成する。これらのデータ
構造体はSQLRA ２０２(SQL要求域) と、SQLDA ２０２(S
QLデータ域) とを含む。そして、ゲートウェーマップ機
構(mapper)は２１０はSQLRA をSQLJRA（ゲートウェーイ
ンタフェース要求域）にマップする。データ構造体(SQL
JRA およびSQLDA)２１４はSQLJRAデータストリームコン
ストラクタに与えられる。そして、SQLJRAデータストリ
ームコンストラクタ２２０はデータストリーム２２０に
対するメモリ要件を計算する。

【００１９】メモリ要件についての情報が（後述する）
データ構造体(SQLCPLEN)に入れられる。SQLJRAデータス
トリームコンストラクタはデータ構造体からデータスト
リーム２２２を構成し、そのデータストリームを通信バ
ッファ２３０に入れることになる。データベースマネー
ジャトランスポートルーチン２４０／２５０は、通信バ
ッファを、トランスポート層通信プロトコルに従って、
通信バッファに伝送する。

【００２０】サーバ側では、データベースマネージャ２
８０トランスポートルーチンは、データストリームを受
信し、通信バッファに入れる。SQLJRAデータ構造体コン
ストラクタ２６０が通信バッファから獲得する最初のも
のは、メモリ要件データ構造体である。メモリ要件デー
タ構造体内の情報の場合、データ構造体を再構成するた
め、サーバは全メモリ要件となるものを計算する。デー
タ構造体コンストラクタは適正なメモリサイズを割り振
り、データをデータストリームから受信して割り振られ
たメモリに入れ、データ構造体を再構成する。

【００２１】再構成されたデータ構造体はゲートウェー
ルータ２７０に与えられる。ゲートウェールータ２７０
はSQLJRAゲートウェーインタフェース構造体をSQLRA に
マップする。SQLRA はデータベースが実際に採用するデ
ータ構造体である。SQLRA とSQLDA はデータベース２８
０に与えられ、SQL 要求を行う。

【００２２】図３はクライアントのSQLJRAデータストリ
ームコンストラクタの詳細なフローを示す。上述したよ
うに、データストリームコンストラクタはサーバにより
必要とされるメモリ要件情報を含むデータ構造体を作成
する必要がある。処理は機能ブロック３００から開始さ
れる。機能ブロック３００にて、位置ポインタは通信バ
ッファの最初に利用可能なレコードに初期設定される。
そして、機能ブロック３１０にて、現バッファ位置ポイ
ンタはSQLCPLENに割り当てられ、２つのデータ構造体の
長さは機能ブロック３２０にて計算される。機能ブロッ
ク３３０および３４０にて、全入力および出力データ長
は適正な変数に割り当てられる。そして、機能ブロック
３５０および３６０にて、入力および出力変数の数が計
算され、通信バッファに置かれる。ついで、機能ブロッ
ク３７０および３９０にて、通信バッファの各変数の長
さが記録され、端子３９２にて、終了する。

【００２３】本発明に係るデータ構造体次の制御構造体
はクライアントがサーバに渡し、メモリとデータ長情報
を示すものである。

【００２４】 このデータ構造体に対する直観的なアプローチは、構造
体を定義することであり、その構造体に値を割り当て、
そして、その構造体を通信バッファに移動することであ
る。その代わり、制御構造体は通信バッファで作成さ
れ、値は適正な制御構造体にストアされる。その場合、
制御構造体をデータストリームにコピーする必要はな
い。

【００２５】・ CS_LENは制御構造体の全体的な長さで
あり、SQLJRAとSQLCPLENを含む。サーバはこの情報を用
い、制御構造体の終りを突き止める。

【００２６】・ IN_DATA_LEN はユーザ入力データ域の
長さである。

【００２７】・ OUT_DATA_LENはユーザ出力データ域の
長さである。

【００２８】・ IN_DATA_LEN およびOUT_DATA_LENはデ
ータ構造体のために必要な全記憶空間を計算するために
用いられ、しかも、ユーザ入力および出力データ域に必
要なセグメント数を計算するために用いられる。

【００２９】・ NUM_OF_VARS は入力および出力sqlvar
s の数である。NUM_OF_VARS の数はSQLDからユーザ入力
SQLDA に渡される。

【００３０】・ NUM_OF_OUT_VARS は出力sqlvars の数
である。NUM_OF_OUT_VARS の値はSQLDからユーザ出力SQ
LDA に渡される。

【００３１】・ SQLVAR_LENは各sqlvarの実際のデータ
長をストアするための配列である。ユーザ入力SQLDA の
各SQLVARは、実際のデータ長を獲得するため検査され
る。サーバはNUM_OF_VARS を用いて入力SQLDA 長(IN_DA
_LEN) を計算し、しかも、NUM_OF_OUT_VARS を用いて出
力SQLDA 長(OUT_DA_LEN)を計算する。

【００３２】図４から分かるように、SQLJRAデータ構造
体４０１は、汎用部分と、ヘッダ情報と、パラメータの
集合とよりなる。ヘッダ情報４００，４１０，４２０，
４３０，４４０，および４５０はSQLJRAデータ構造体と
要求タイプを記述する。各パラメータ４６０はトリプレ
ットであり、長さと、タイプと、ポインタとよりなる。
このステップは、パラメータポインタにより指示された
データを、通信データストリームを含む通信バッファに
移動する。この機能をインプリメントする直観的な方法
は、一時的に、パラメータポインタを参照解除させて１
にし、そのデータをデータストリームに置く方法であ
る。各トリプレットはその構造が同一であるので、トリ
プレットポインタを参照解除するため、ループを形成す
るのがより効率的である。

【００３３】トリプレット構造体が定義され、このトリ
プレット構造体を指示するポインタを用いて第１のSQLJ
RAトリプレットアドレスとしてキャストされる。そし
て、トリプレットポインタを採用して、各SQLJRAパラメ
ータにアクセスする。

【００３４】第４に、クライアントは入力および出力SQ
LDA をデータストリームに移動させる。最後に、クライ
アントはユーザ入力SQLDA を介してループを形成し、入
力データをデータストリームに置く。各sqlvarはその構
造が同一であるので、我々がSQLJRAに対して用いた同一
の技法を本実施例でも適用する。

【００３５】図５はサーバ上のデータ構造体再構成機構
の詳細なフローを示す。機能ブロック５００にて、デー
タ構造体再構成機構が通信バッファから獲得する最初の
ものはデータ長制御構造体である。機能ブロック５１０
にて、この情報を用いて、データ構造体に対して必要と
する前記記憶空間(M) を計算する。機能ブロック５２０
にて、最初に、データ構造体(M) が必要とするメモリの
サイズを判定した結果、通信バッファ(B) のサイズ未満
である場合、余分のメモリを必要としない。SQLJRA遠隔
プロトコルはこれらのデータ構造体をそのまま渡すの
で、機能ブロック５２２にて、通信バッファを用いてデ
ータ構造体を再構成する。機能ブロック５２４にて、ク
ライアントは各データ構造体の開始位置を突き止め、新
しいアドレスをSQLJRAのポインタフィールドに割り当て
る。そして、端子５２６にて終了する。

【００３６】機能ブロック５２０にて、必要なメモリサ
イズが１つの通信バッファのサイズを超える場合、機能
ブロック５３０にて、サーバはデータ構造体を収めるこ
とができるバッファを割り振る。バッファの位置がＢで
ある場合、通信バッファのサイズはＣであり、通信バッ
ファの位置はＬである場合、サーバが呼び出した受信数
はｉである。

【００３７】まず、機能ブロック５４０にて、サーバは
通信バッファの内容をサーババッファにコピーする。コ
ピーが終了した後、機能ブロック５５０および５６０に
て、サーバは次に示す式に従って通信バッファのアドレ
スを動的に調整する。

【００３８】

【数１】Ｌ＝（Ｂ＋（ｉ−１）＊Ｃ）−２ サーバにより受信された実際のデータ長にするため、Ｓ
ＮＡが通信バッファの最初の２バイトを必要とするの
で、Ｌから２が引き算される。受信する前に、サーバは
通信バッファの最後の２バイトを保管する必要があり、
しかも、受信後、再ストアする必要がある。機能ブロッ
ク５６０にて、受信された全データは順番にサーババッ
ファに入れられる。全データが受信された後、機能ブロ
ック５２４にて、サーバはデータ構造体の開始点を突き
止め、ポインタをSQLJRA制御構造体に割り当てる。

【００３９】図６は本発明に係るデータ構造体再構成の
例を示す。Ｌ１ ６０２は第２受信に対する通信バッフ
ァ６００アドレスであり、Ｌ２ ６０３は第３受信に対
する通信バッファアドレスであり、Ｌ３ ６０４は第４
受信に対する通信バッファアドレスてある。サーバによ
り受信されサーババッファ６１０に、全データが入られ
た後、サーバはデータ構造体６２０内のポインタを調整
する。

【００４０】 本発明に係るＣソースコード（appendix） /*****************************_PROLOGUE_**************************** ** * * *OCO SOURCE MATERIALS * * * *MODULE NAME: sqlcpsvr * * * *COMPONENT NAME: Distributed Data Services * * JRA data stream server * * * *LPP NAME: Gemstone * * * *DESCRIPTIVE NAME: Receive JRA data stream * * * *COPYRIGHT: program-number (C) COPYRIGHT IBM CORP 1991 * * * *STATUS Development Phase * * * *FUNCTION: * * このモジュールは、JRA データストリームを受信し、* * データベースエンジンに送信し、その結果をリクエ * * スタに戻す関数の集合を含む。

【００４１】 * * *COMPILER OPTIONS: * * see sqlc.cop * * * *INPUT: * * * * データ要求の標準データフロー： * * * * 項目 要素 * * --------------------------------* * 1. 第１通信バッファのデータ量 * * 2. SQLJRA (有意のデータが任意のポインタ * フィールドに存在しない） * * 3. 制御構造体の長さ（項目#9まで（高々項目#10 まで))。 * * 項目#1(2 bytes) は含まない。 * * 4. input dataの長さ * * 5. output data （存在する場合）の長さ* * 6. 配列#8の項目の数 * * 7. output SQLVARSの数。 output DAが存在しない場合、* * その数は０である。 * * 8. input data項目の実際の長さの配列（input SQLDA * * の長さは最大にすることができる。） * * 9. SQLJRAパラメータ（ポインタによりアクセス * されるフィールドのデータ） * * 10. input SQLDA （データなし） * * 11. output SQLDA（データなし） * * 12. input data * * * * 注意: おそらく全てが第１バッファであろう。 * * * *OUTPUT: * * * * サーバから戻されたデータの標準データフロー * * * * 項目 要素 * * --------------------------------* * 1. 第１通信バッファのデータの量(unsigned int) * * 2. sqledscr（ルータ）からの2 byteの戻りコード * * 3. SQLCA に対するNULL識別子。０である場合、 * * SQLCA が戻される。０未満の場合、SQLCA は戻 * * されない。SQLCA はデータベースを用いて常に * * start に戻される。 * * 4. 任意指定SQLCA 。項目#3の記述を参照。 * * * * 戻されたデータの残りはSQLJRA要求タイプに依存する。 * * * * 実行コマンドについて： * * * * 5. データに対するNULL識別子。０である場合、データ行 * * が戻される。０未満の場合は、データ行は戻されない。* * 6. データ行。各データ行はｎ個のSQLVARよりなる。 * * ただし、ｎはoutput SQLDAでリストアップした数であ * る。各SQLVARは次のものよりなる。 * * * * 1. NULL 識別子。データがNULLであるか、存在するか * * を記述する。０はデータを示す。０未満はデータが * * 送信されないことを示す。 * * 2.任意指定データ。項目5.1 の記述参照。 * * * * コマンドを用いたstart について: * * * * 5.データベース名 (10 bytes). * * 6.サーバSBCSコードページ(2 bytes). * * 7.サーバcomm buffer の長さ(2 bytes). * * 8.サーバプロセス ID (2 bytes). * * 9.サーバスレッド ID (2 bytes). * * 10. サーバリリースレベル(10 bytes). * * * * 作成および記述コマンドについて： * * * * 5.用いられたoutput SQLVARS の数 (output DA * * sqld フィールド -2 bytes)* * 6.任意指定 output DA（データなし）。このDAは * * output DA sqldフィールドが割り振られたサイズ * * より小さいか、あるいは等しい場合にのみ送信される。 * * ( output DA sqln フィールド) 。 * * * ******************************************************** * カーソルがブロッキングを用いているときのみの * fetch について： * * このフローは他のフローと異なる。各行は実行コマンド * * と同一のフローを有する。 * * * * 1. 第１通信バッファのデータの量(unsigned int) * 2. このバッファに取り出された行の数。 * * 3. このバッファの最後の行はカーソルから取り出す* * ことができる最後の行か。 0 = no, -1 = yes * * * * この後、各行はつぎのものよりなる: * * * * 4. sqledscr（ルータ）からの2 bytes の戻りコード。* * 5. SQLCA に対するNULL識別子。０の場合、SQLCA が * * 戻される。０未満の場合は、 SQLCAは戻されない。* * 6. 任意指定 SQLCA. 項目#5の記述参照。 * * 7. データに対するNULL識別子。０の場合、データ行が * * 戻される。０未満の場合は、データ行は戻されない。* * 8. データ行。各データ行はｎ個のSQLVARよりなる。ここで、 ** ｎはoutput SQLVAR でリストアップされた数。

【００４２】 * 各 SQLVAR は次のものよりなる。

【００４３】 * * * 1.NULL識別子。データがNULLか、存在するか * * を記述する。０はデータを示す。０未満は* * データが送信されないことを示す。 * * 2.任意指定データ。項目7.1 の記述を参照。 * * * * ブロッキングがカーソル上で用いられるときのオープン * * カーソルについて： * * * * * * 1. 第１通信バッファのデータの量(unsigned int) * * 2. sqledscr（ルータ）からの2 byteの戻りコード。 * * 3. SQLCA に対するNULL識別子。０の場合、SQLCA が * * 戻される。０未満の場合は、SQLCA は戻されない。* * SQLCA はデータベースを用いて常にstart に戻され * * る。 * * 4. 任意指定 SQLCA。項目#3の記述を参照。 * * 5. 用いられる output SQLVARS の数(output DA sqld * * フィールド -2 bytes) * * 6. 任意指定output DA （データなし）。このDA * * は、output DA sqldフィールドが割り振られたサイズ * * より小さいか、あるいは等しい場合にのみ送信される * * （ output DA sqln フィールド）。

【００４４】 * 7. このバッファに取り出された行の数。 * * 8. このバッファの最後の行はカーソルから取り出すこと * * ができる最後の行か。0 = no, -1 = yes. * 9. 任意のデータ行 (if #7 > 0)。行内容に対する上記 * * fetch 記述参照。 * * 注意：おそらく全てが第１バッファであろう。 * * * *RETURN CODE: * * See individual function description * *******************************************************/ /******************************************************/ /*** Include statements. ***/ /******************************************************/ #define SQLZ_STACK /* apiマクロを呼び出さない */ #define LINT_ARGS 1 #define INCL_SQLOMMDC #define INCL_SQLOIPDC 1 #include "sqlz.h" #include "sqlo.h" #include "sqlocall.h" #include "sqlenv.h" #include "sqljra.h" #include "sqljrai.h" #include "sqler.h" #include "sqlra.h" #include "sqlca.h" #include "sqlcc.h" #include "sqlcm.h" #include "sqlcmi.h" #include "sqle.h" #include "sqleapi.h" #include "sqlei.h" #include "sqltc.h" #include "sqlchdda.h" #include "sqlc.h" #include "sqlci.h" #include "sqlcodes.h" #include "sqlrx.h" #include "sqlda.h" #include "sql.h" #include "sqlcitoh.h" #include "sqlcpcom.h" #include "sqlcpccb.h" #include "sqlcpsvr.h" /******************************************************/ /* Function name: SQLCPSVR_RECEIVE */ /* Function: */ /* Receive a JRA request from a client, and marshall it. */ /* Input: */ /* DDSACB pointer */ /* Output: /* Return code of status of operation. */ /******************************************************/ short SQLZ_LOCAL sqlcpsvr_receive(struct sqlcacb *ddsacb) { short retcode = 0; /* 関数戻りコード */ short t_count, t_count 2; /*ループ変数 */ unsigned char *buf_ptr; /*大きいバッファをスキャン する際に用いるポインタ*/ unsigned char *cb_buf_ptr; /*daの分析にのみ用いる */ unsigned short buffer_len; /*comm buffer の長さ */ unsigned long total_len; /*要求全体の合計の長さ */ unsigned long total_input_len; /*output data を除いた合計の長さ */ unsigned long ctl_struct_len; /*制御構造体の長さ */ unsigned long in_data_len; /*input dataの長さ*/ unsigned long out_data_len; /*output data の長さ */ unsigned long num_in_sqlvars; /*input dataの長さの配列のエントリ数 */ unsigned long num_out_sqlvars; /*output SQLVAR の数 */ unsigned long input_da_len; /*input DA（データなし）長さ */ char *jra_params; /* SQLJRA パラメータのポインタ */ char **triplet_ptr; /*SQLJRAのtriplet を指すポインタ ＊／ ポインタ */ unsigned long *in_da_lens; /*実際のinput DAの長さの配列を指す ポインタ */ struct sqlda *in_da_ptr = NULL; /*バッファの input DA を指すポインタ */ char *input_data; /*input dataの startを指すポインタ*/ char *output_data; /*output data の startを指すポインタ */ struct sqlvar *t_sqlvar; /*SQLDA からのSQLVARを指すポインタ */ struct sqlda *private_out_da; /* output DA の私用コピー */ /* move_data call */ unsigned long total_received; /*これまでに受信された合計 */ unsigned int amt_to_copy; /*残りのコピーの量 */ unsinged int temp_holder; /*次のcomm buffer をコピーする間に 最後の2 byteのバッファを保持する 変数。*/ unsigned short receive_length; /*受信されたデータの長さ */ unsigned short parse_da_data = FALSE; /* da に対するデータが複数のバッファに goしなければならないか否かを明らかに するためそのデータを分析すべきか。 */ unsinged long *t_in_da_lens; /*実際のinput の配列を指すポインタ */ unsigned short start_var; /*このセグメントで第１ sqlvar はどれか*/ unsigned short total_var_space; /*カーソルセグメントで用いられる容量*/ unsigned short this_var_space; /*この変数がとる容量 */ short done_with_input; /*input 変数を処理したか */ unsigned char *t_run_ptr; /*runstat の一時ポインタ */ unsigned char *t_addr_ptr; /*runstat の一時ポインタ */ struct sqlcp _ccb *temp_ccb; /*一時 CCBポインタ. */ unsigned long rcv_out_da_len; /*リクエスタにより送信された output DA の長さ。 */ **************************************************/ /*comm buffer のアドレスをget*/ /*バッファのデータの長さをget*/ /*（バイト逆転させる） */ /*バイト逆転する*/ /*SQLJRAのstart を指すポインタを移動*/ comm_buffer = ddsacb->buffer; sqlzmcpy(&buffer_len, comm_buffer, SQLC_SHORT_SIZE); buffer_len + SQLC_SWAP2(buffer_len); comm_buffer += SQLC_SHORT_SIZE; /*SQLJRAを指すポインタをバッファにセ */ /*ット */ /*長さフィールドに移動 */ dcsra = (SQLJDSRA *)&comm_buffer[0]; comm_buffer += sizeof(SQLJDSRA); /* SQLCAをSQLJRAに割り当て*/ dcsra->sqlrcap = (char *)&ddsacb->cb.aacb.sqlca; /*エラーなし*/ /*out DA記憶域に対するステータス変数 */ /*をクリア */ /*要求タイプを我々に通知する変数をク */ /*リア。 */ /*我々は特別の処理を要求する特定の要 */ /*求タイプのみを処理する。 */ /*start using か否かを見付け出す。 */ /*これがcompile ステートメントか否かを見 */ /*付け出す。comlile ステートメントには */ /*intput DA は有るが、input dataはない。 */ /*DAはホスト変数に対するSQLVAR長さと名前 */ /*情報を有する。我々はデータポインタをDA */ /*にセットしようとしない。これが runstat */ /*か否かを見付け出す。runstat にはinput */ /*DAは有るが、データはない。

【００４５】 /*我々は、input DAを指すため、DCSRA-> */ /*SQLJRDATA[1]フィールドのポインタを調整 */ /*しなければならない。特別の処理を必要と */ /*する幾つかの他のタイプのコマンドである */ /*か否かを見付け出す。 */ error_found = 0; allocate_out_da = 0; start_using = 0; compile = 0; runstat = 0; prep_desc = 0; ari = 0; op_stat = 0; open_cursor = 0; close_cursor = 0; fetch = 0; exec = 0; blocking = 0; switch (dcsra->sqltype) { case SQLJ_DCSSV: switch (dcsra->sqlrtype) { case SQLJR_STARTGW: start_using = 1; if (ddsacb->length > SQLC_SIZE_MAXQRYBLK) { ddsacb->length = SQLC_SIZE_MAXQRYBLK); } break; case SQLJR_RPC: ari = 1; break; case SQLC_RT_OPSTAT: op_stat = 1; break; } break; case SQLJ_DBSV: switch (dcsra->sqlrtype) { case SQLJR_COMPILE: compile = 1; break; case SQLJR_RUNSTATS: runstat = 1; break; case SQLJR_PREPARE: case SQLJR_DESCRIBE: prep_desc = 1; break; case SQLJR_OPEN: open_cursor = 1; break; case SQLJR_CLOSE: close_cursor = 1; break; case SQLJR_FETCH: fetch = 1; break; case SQLJR_EXECUTE: exec = 1; break; } break; ｝ /*制御構造体をget する */ /*input dataの長さをget する */ /*output data の長さをget する。 */ /*input sqlvars の数をget する*/ /*output sqlvarsの数をget する*/ /*input DAの数をget する */ /* JRAが０である場合、そのままにしておく。 */ /* そうでない場合、num_in_var sqlvar のDA である。これはJRA のサイズより小さくする ことができる。（sqldフィールドが sqln よ り小さい場合）*/ /*記憶割り振りおよび受信に対してoutput DA のサイズをget する*/ sqlzmcpy(&ctl_struct_len, comm_buffer, SQLC_LONG_SIZE); comm_buffer += SQLC_LONG_SIZE; sqlzmcpy(&in_data_len, comm_buffer, SQLC_LONG_SIZE); comm_buffer += SQLC_LONG_SIZE; sqlzmcpy(&out_data_len, comm_buffer, SQLC_LONG_SIZE); comm_buffer += SQLC_LONG_SIZE; sqlzmcpy(&num_in_sqlvars, comm_buffer, SQLC_LONG_SIZE); comm_buffer += SQLC_LONG_SIZE; sqlzmcpy(&num_out_sqlvars, comm_buffer, SQLC_LONG_SIZE); comm_buffer += SQLC_LONG_SIZE; if (compile) { input_da_len = dcsra->sqlrdail; } else { input_da_len = (dcsra->sqlrdail > 0) ? SQLDASIZE(num_in_sqlvars) : 0; } output_da_len = dcsra->sqlrdaol; rcv_out_da_len = output_da_len; if (output_da_len > 0) { rcv_out_da_len = SQLDASIZE(num_out_sqlvars); } /*クライアントから送信されたデータの長さ*/ をget する。それは、次のものよりなる。*/ /*1) 2 bytes−バッファの長さ*/ /*2)制御構造体のサイズ */ /*3)input/output DA のサイズ*/ /*4)input dataのサイズ*/ /*我々が必要な全空間をget する。*/ /*全空間は入力空間と、output data */ /*に対して必要な空間との和に等しい。*/ total_input_len = SQLC_SHORT_SIZE + ctl_struct_len + input_da_len + rcv_out_da_len + in_data_len; total_len = SQLC_SHORT_SIZE + ctl_struct_len_input_da_len + output_da_len + in_data_len + out_data_len; /*全てがcomm buffeに収まる場合.. */ /*1)我々はセグメントを必要としない。*/ /*2)残りのバッファ操作に対して ポインタをセットアップする。*/ If (total_len <= ddsacb->length) { num_segs_needed = 0; buf_ptr = comm_buffer; } else { /*１つのセグメント(64k以下) に収まる場合、*/ /*１つのセグメントが必要なことにマークを付ける*/ /*セグメントをget する*/ /*そのセグメントにcomm buffeをコピーする*/ /*次の受信のため、ポインタをそのセグメントにセットする*/ /*第１の受信の長さをget する。*/ /*これまで受信したものとしてマークを付ける*/ /*get するものがある間.. */ /*残りのコピー量を見付け出す */ /*１つのバッファ未満である場合... */ /*受信すべき量を調整する*/ /*受信された最後の2 byteを保管する */ /*次のバッファをget する */ /*2 bytes をコピーバックする（新しいバッファの LL フィールド*/ /*に）合計をインクリメントする */ /*次の受信に移行する */ If (total_len <= SQLO_MAXSEGSIZ) { retcode = sqloallocseg((unsigned int) total_len, (char **)&segments[0], SQLO_MM_SHARE_GIVE); If (retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR",(long) SQL_RC_E954); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 102, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } num_segs_needed = 1; sqlzmcpy(segments[0], ddsacb->buffer, buffer_len); buf_ptr = segments[0] + buffer_len - SQLC_SHORT_SIZE; receive_length = ddsacb->length; total_received = receive_length; while (total_received < total_input_len) { amt_to_copy = (unsigned int)(total_input_len - total_received + SQLC_SHORT_SIZE); if (amt_to_copy < ddsacb->length) { receive_length = amt_to_copy; } sqlzmcpy(&temp_holder, buf_ptr, SQLC_SHORT_SIZE); retcode = sqlccrcv(&(ddsacb->comhandle), &receive_length, buf-ptr, SQLC_FILL); if(retcode != 0) { sqlcperc(&ddsacb->comhandle, (struct sqlca*)dcsra->sqlrcap, "SQLCPSVR"); /* sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E30080); */ sqlt_system_error(SQLT_SQLC, SQLT_SQLCPSVR, 108, sizeof(short), &retcode); retcode = SQLJR_RCF_TERMINATE｜SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } sqlzmcpy(buf_ptr, &temp_holder, SQLC_SHORT_SIZE); total_received += receive_length - SQLC_SHORT_SIZE; buf_ptr += receive_length - SQLC_SHORT_SIZE; } /* SQLJRA ポインタをセットアップする */ /*新しいバッファの場所にマークを付ける */ dcsra = (SQLJDSRA *)((char *)segments[0] + SQLC_SHORT_SIZE); buf_ptr = segments[0] + (comm_buffer - ddsacb->buffer); } else { /*最低３つのバッファを必要とする */ /*バッファに制御構造体 (SQLJRA...)を割り振る */ /*バッファにinput daを割り振る*/ /*バッファにoutput da を割り振る*/ /*daデータを分析しなければならないことにマークを付ける */ retcode = sqloallocseg((unsigned int)(SQLC_SHORT_SIZE + ctl_struct_len), (char **)&segments[0], SQLO_MM_SHARE_GIVE); if (retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long)SQL_RC_E954); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 103, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } num_segs_needed = 1; retcode = sqloallocseg((unsigned int) input_da_len, (char **)&segments[1], SQLO_MM_SHARE_GIVE); If (retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR",(long) SQL_RC_E954); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 104, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } num_segs_needed = 2; retcode = sqloallocseg((unsigned int)output_da_len, (char **)&segments[2], SQLO_MM_SHARE_GIVE); if(retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E954); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 105, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } num_segs_needed = 3; parse_da_data = TRUE; /*第１comm buffer のstart をget する*/ /*制御データを受信してセグメントに入れる*/ /*input daがある場合は、そのデータをget する */ /*output da がある場合は、そのデータをget する*/ cb_buf_ptr = ddsacb->buffer; retcode = sqlcpgd(ddsacb, &cb_buf_ptr, ddsacb->buffer, segments[0], (unsigned int)(SQLC_SHORT_SIZE + ctl_struct_len), FALSE); if (retcode != 0) { sqlcperc(&ddsacb->comhandle, (struct sqlca *)dcsra->sqlrcap, "SQLCPSVR"); /* sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E30080); */ sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 109, sizeof(short), &retcode); retcode = SQLJR_RCF_TERMINATE ｜ SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } if (input_da_len > 0) { retcode = sqlcpgd(ddsacb, &cb_buf_ptr, ddsacb->buffer, segments[1], (unsigned int)(input_da_len), FALSE); if (retcode != 0) { sqlcperc(&ddsacb->comhandle, (struct sqlca *)dcsra->sqlrcap, "SQLCPSVR"); sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E30080); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 110, sizeof(short), &retcode); retcode = SQLJR_RCF_TERMINATE | SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } } if (rcv_out_da_len > 0) { retcode = sqlcpgd(ddsacb, &cb_buf_ptr, ddsacb->buffer, segments[2], (unsigned int)(rcv_out_da_len), FALSE); if (retcode != 0) { sqlcperc(&ddsacb->comhandle, (struct sqlca *)dcsra->sqlrcap,"SQLCPSVR"); /* sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E30080); */ sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 111, sizeof(short), &retcode); retcode = SQLJR_RCF_TERMINATE｜SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } } /*SQLJRAポインタをセットアップする*/ /*新しいバッファの場所にマークを付ける */ dcsra = (SQLJDSRA *)((char *) segments[0] + SQLC_SHORT_SIZE); buf_ptr = segments[0] + (comm_buffer - ddsacb->buffer); } } /*実際のinput DA長の配列のstart を指すポインタをget する */ /*comm buffer ptr をJRA パラメータに移動する */ /* JRAパラメータを指すポインタをget する*/ in_da_lens = (unsigned long *)&buf-ptr[0]; buf_ptr += (num_in_sqlvars * SQLC_LONG_SIZE); jra_params = (char *)&buf_ptr[0]; /*第１triplet を指す。*/ /*識別子配列が最初であると仮定!!*/ /*各tripleteに対して..*/ /*ポインタフィールドをセットして 適正なパラメータフィールドを指す*/ /*ポインタをフィールド長に基づき パラメータフィールドに移動する */ /*次のtriplet に移動する */ triplet_ptr = &(dcsra->sqlrflag); length_ptr = &(dcsra->sqlrflgl); for (t_count = 0; t_count < SQLC_NUM_TRIPLETS; t_count++) { if (((unsigned long) *length_ptr) > 0) { *triplet_ptr = jra_params; jra_params += (unsigned long) *length_ptr; } else { *triplet_ptr = NULL; ｝ triplet_ptr = (char **)((char *) triplet_ptr + SQLC_TRIPLET_SIZE); length_ptr = (unsigned long *)((char *) length_ptr + SQLC_TRIPLET_SIZE); } /* ポインタをDAエリアのstart にセットする*/ /*output DAポインタを初期設定する*/ /*input DA が存在する場合は、ポインタを セットする*/ /* これがcomm buffer にある全てである場合、*/ /* 私用記憶領域をget する*/ /*getできない場合は、エラーを発生しここから 抜ける*/ /*DA を私用記憶領域にコピーする */ /* 注意: Output DA をバッファからコピー しなければならない。戻りデータを記憶する とき、Output DA をワイプアウトする ことができるからである。（ついで、我々は Output DA を必要とする）*/ buf_ptr = (char *)dcsra + ctl_struct_len; out_da_ptr = NULL; If (input_da_len > 0) { in_da_ptr = (struct sqlda *)((parse_da_data)? segments[1] : buf_ptr); } if (output_da_len > 0) { out_da_ptr = (struct sqlda *)((parse_da_data)? segments[2] : (buf_ptr + input_da_len)); allocate_out_da = FALSE; if (num_segs_needed == 0) { retcode = sqlogblk(ddsacb->rsheap, (unsigned) output_da_len, &private_out_da); if(retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long)SQL_RC_E962); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 102, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } allocate_out_da = 1; sqlzmcpy(private_out_da, out_da_ptr, (unsigned int) output_da_len); out_da_ptr = private_out_da; } } /*input とoutput SQLDAを指すポインタ をセットする */ dcsra->sqlrdapi = (char *)in_da_ptr; dcsra->sqlrdapo = (char *)out_da_ptr; /* runstat オペレーションである場合... */ /* ポインタ配列のstart を指すポインタ を適正なtriplet にget する */ /* 索引の数だけループする */ /*（SQLVARに存在する）索引名を含む ストリングのアドレスをデータtrilet にput する*/ /*次の索引にtriplet で移行する*/ if (runstat) { t_run_ptr = dcsra->sqlrdata[1].sqlrdtp; for (t_count = 0; t_count < (short)(dcsra->sqlrdata[1].sqlrdtl / SQLC_LONG_SIZE); t_count++) { t_addr_ptr = (char *) in_da_ptr->sqlvar[t_count].sqlname.data; sqlzmcpy(t_run_ptr, &t_addr_ptr, SQLC_LONG_SIZE); t_run_ptr += SQLC_LONG_SIZE; } /*索引の数をtriplet に固定する。*/ /*JRACのinput daをクリアする。（input daのみが 索引名のために必要である。）*/ dcsra->sqlrdata[1].sqlrdtl /= SQLC_LONG_SIZE; dcsra->sqlrdapi = NULL; dcsra->sqlrdail = 0; } /*input dataポインタをクリアする*/ /*input daが存在し、かつ、"compile SQL" ステートメントではなく、かつ、"runstat" ステートメントではないとき、 */ /*セグメントのinput dataを必要とする場合 */ input_data = NULL; if((in_da_ptr != NULL) && (!compile) && (!runstat)) { if (!parse_da_data) { /*input dataを処理しなければならない*/ /*input dataが存在する場合... */ /*全てのsqlvarに対してループ。各 SQLVAR に対して.. */ /*1)SQLVARを指すポインタをget する */ /*2)列データがNULL... である場合 */ /* NULL ポインタをセットアップする*/ /* バッファに転送*/ /*3) Else, */ /* データポインタをセットアップする*/ /* このデータ項目のサイズをデータに移動 （次の項目に） */ /*4)長さの配列の次の長さに移動 */ input_data = (char *)(buf_ptr + input_da_len + rcv_out_da_len); for (t_count = 0; t_count < (unsigned int) num_in_sqlvars; t_count++) { t_sqlvar = (struct sqlvar *) &(in_da_ptr->sqlvar[t_count]); if ((t_sqlvar->sqltype & SQL_TYP_NULINC) != 0) { t_sqlvar->sqlind = (short *)input_data; input_data += SQLC_SHORT_SIZE; } if (((t_sqlvar->sqltype & SQL_TYP_NULINC) == 0)｜| ((short) *t_sqlvar->sqlind >= 0)) { t_sqlvar->sqldata = (unsigned char *)input_data; input_data += (unsinged long) *in_da_lens; } in_da_lens = (unsigned long *)((char *) in_da_lens + SQLC_LONG_SIZE); } } else { /*Else 1つ以上のセグメントを必要とする */ /*入力長さを指すポインタを保管する*/ /*このセグメントの第１変数値を保管する*/ /*まだ変数は保管されていない */ /*全ての sqlvarsに対して... */ /*入力をまだ処理していない */ t_in_da_lens = in_da_lens; start_var = 0; total_var_sapce = 0; done_with_input = FALSE; for (t_count = 0; t_count < (unsigned int) num_in_sqlvars; t_count++) { /* SQLVAR をget する*/ /*この変数に対して必要な空間を getする*/ t_sqlvar = (struct sqlvar *) &(in_da_ptr->sqlvar[t_count]); this_var_space = 0; if ((t_sqlvar->sqltype & SQL_TYP_NULINC) != 0) { this_var_space = SQLC_SHORT_SIZE; } this_var_space += (unsigned short) ((unsigned long) *in_da_lens); /* この変数がセグメントに収まらない場合 */ /*セグメントを前の変数に割り振る */ /*セグメントのデータをget する*/ if ((unsigned long) total_var_space + this_var_space > SQLO_MAXSEGSIZ) { alloc_space: retcode = sqloallocseg(total_var_space, (char **)&segments[num_segs_needed], SQLO_MM_SHARE_GIVE); if (retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E954); sqlt_trace_error(SQLT-SQLC, SQLT_SQLCPSVR, 106, sizeof(short), retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } retcode = sqlcpgd(ddsacb, &cb_buf_ptr, ddsacb->buffer, segments[num_segs_needed], total_var_space, FALSE); if (retcode != 0) { sqlcperc(&ddsacb->comhandle, (struct sqlca *)dcsra->sqlrcap, "SQLCPSVR"); /* sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E30080); */ sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 112, sizeof(short), &retcode); retcode = SQLJR_RCF_TERMINATE｜SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } /* 戻らなければならない。セグメントのポインタを 更新する*/ /*このセグメントの変数に対するループ*/ /*SQLVARをget する*/ /*Null識別子またはデータを更新する*/ /*長さポインタを移行する */ input_data = segments[num_segs_needed]; for (t_count2 = start_var; t_count2 < t_count; t_count2++) { t_sqlvar = (struct sqlvar *) &(in_da_ptr->sqlvar[t_count2]); if ((t_sqlva->sqltype & SQL_TYP_NULINC) != 0) { t_sqlvar->sqlind = (short *) input_data; input_data += SQLC_SHORT_SIZE; } if (((t_sqlvar->sqltype & SQL_TYP_NULINC) == 0) || ((short) *t_sqlvar->sqlind >= 0)) { t_sqlvar->sqldata = (unsigned char *)input_data; input_data += (unsigned long) *t_in_da_lens; } t_in_da_lens = (unsigned long *) ((char *)t_in_da_lens + SQLC_LONG_SIZE); } /*次のセグメントのためにセットアップ*/ /*長さのstart を保管する*/ /*現変数のサイズが現在の合計である */ /*現変数がセグメントの第１変数である */ /*次のセグメントに移行する */ t_in_da_lens = in_da_lens; total_var_space = this_var_space; start_var = t_count; num_segs_needed++; /*最後の変数をバッファに入れている 場合、スキップする*/ if (done_with_input) { goto exit_input; } } else { /* 収まる場合は、この変数を合計に加算する */ total_var_space += this_var_space; } /* 次の変数の長さをget する*/ in_da_lens = (unsigned long *)((char *)in_da_lens + SQLC_LONG_SIZE); ｝ /*ループを処理するが、最後の SQLVAR(s)を セグメントにput する必要がある。*/ /*フラグをセットし、処理のため戻る */ done_with_input = TRUE; goto alloc_space; exit_input:; } } /* 出力データが存在する場合は、作成でも、 記述でもない*/ If ((out_da_ptr != NULL) && (!prep_desc)) { /* 割り振られた１つのセグメントに全output dataが収まらない場合*/ if (!parse_da_data) { /* 全ouput dataが１つのエリアに駐在する （セグメント化される必要はない）*/ /* 各output SQLVAR に対して...*/ /* 1)SQLVARを指すポインタをget する*/ /* 2)このフィールドをNULLにでき、かつ、*/ /* リクエスタにNULLポインタが存在する場合、*/ /*null 識別子にポインタをセットする*/ /*output data に転送する*/ /*3) そのデータにポインタをセットする */ /*4)output dataに転送する/ If (input_data == NULL) { output_data = (char *)(buf_ptr + input_da_len + rcv_out_da_len); } else { output_data = (char *)(input_data); } for (t_count = 0; t_count < out_da_ptr->sqld; t_count++) { t_sqlvar = (struct sqlvar *) &(out_da_ptr->sqlvar[t_count]); if (((t_sqlvar->sqltype & SQL_TYP_NULINC) != 0) && (t_sqlvar->sqlind == 0)) { t_sqlvar->sqlind = (short *)output_data; output_data += SQLC_SHORT_SIZE; } else { t_sqlvar->sqlind = NULL; } t_sqlvar->sqldata = (unsigned char *)output_data; output_data += sqlcpdlr(t_sqlvar); } } else { /* １つ以上のoutput data セグメントを 必要とする場合、*/ /* このセグメントの第１変数値を保管する*/ /* 変数がまだ保管されていない*/ /* 全てのsqlvarに対して*/ /* input を処理しない*/ start_var = 0; total_var_space = 0; done_with_input = FALSE; for (t_count = 0; t_count < out_da_ptr->sqld; t_count++) { /*SQLVAR をget する*/ /* この変数に対して必要な空間をget する */ t_sqlvar = (struct sqlvar *)&(out_da_ptr->sqlvar[t_count]); if (((t_sqlvar->sqltype & SQL_TYP_NULINC) != 0) && (t_sqlvar->sqlind == 0)) { this_var_space = SQLC_SHORT_SIZE; } else { this_var_space = 0; } this_var_space += sqlcpdlr(t_sqlvar); /* この変数がセグメントに収まらない場合 */ /*セグメントを前の変数に割り振る */ /* データをセグメントにget する */ if ((unsigned long) total_var_space + this_var_space > SQLO_MAXSEGSIZ) { alloc_space_out: retcode = sqloallocseg(total_var_space, (char **)&segments[num_segs_needed], SQLO_MM_SHARE_GIVE); if (retcode != 0) { sqlcpsca((struct sqlca *)dcsra->sqlrcap, "SQLCPSVR", (long) SQL_RC_E954); sqlt_trace_error(SQLT_SQLC, SQLT_SQLCPSVR, 107, sizeof(short), &retcode); retcode = SQLJR_RCF_SQLCA; error_found = 1; goto rcv_end; } /*戻って、セグメントのポインタ を更新する*/ /*このセグメントの変数に対する ループ*/ /*SQLVARをget する*/ /*null識別子またはデータのいずれか を更新 */ /*長さポインタを移行する */ output_data = segments[num_segs_needed]; for (t_count2 = start_var; t_count2 < t_count; t_count2++) { t_sqlvar = (struct sqlvar *) &(out_da_ptr->sqlvar[t_count2]); if ((t_sqlvar->sqltype & SQL_TYP_NULINC != 0) && (t_sqlvar->sqlind == 0)) { t_sqlvar->sqlind = (short *)output_data; output_data += SQLC_SHORT_SIZE; } else { t_sqlvar->sqlind = NULL; } t_sqlvar->sqldata = (unsigned char *)output_data; output_data += sqlcpdlr(t_sqlvar); } /* 次のセグメントに対してセット アップする*/ /* 現変数のサイズは現在の合計である*/ /* 現変数はセグメントの第１変数で ある*/ /* 次のセグメントに転送する */ total_var_space = this_var_space; start_var = t_count; num_segs_needed++; /* 最後の変数をバッファにput する場合、 スキップする*/ if (done_with_input) { goto exit_output; } } else { /* 収まる場合は、この変数を合計に 加算する*/ total_var_space += this_var_space; } } /* ループ処理中、最後のSQLVAR(s) を セグメントにput する必要がある。*/ /* フラグをセットし、take care of the m のために戻る*/ done_with_input = TRUE; goto alloc_space_out; exit_output: ; } } /*取り出し要求である場合、*/ /*CCB をget する */ /*blockingである場合、*/ /*blockingフラグをONする */ /*戻すためにバッファをセット アップする */ /*戻すバッファにデータをセット アップする*/ if (fetch) { sqlcpcsr(temp_ccb, svr_ccbs, *((unsigned short *)dcsra->sqlrsect), dcsra->sqlrcrea, (unsigned short)dcsra->sqlrcrel, dcsra->sqlrpgmn, (unsigned short)dcsra->sqlrpgml); if (temp_ccb != NULL) { blocking = 1; comm_buffer = ddsacb->buffer + SQLC_SHORT_SIZE; sqlcpfet(ddsacb, &comm_buffer, temp_ccb); } } rcv_end: /*input DA の内容をトレース*/ if(in_da_ptr != NULL) { sqlt_trace_miscl(SQLT_SQLC, SQLT_SQLCPSVR, 190, (short) input_da_len, (void *)in_da_ptr); } return(retcode); } /*******************_PROLOGUE_****************************** ** * * * * OCO SOURCE MATERIALS * * * * IBM CONFIDENTIAL (IBM CONFIDENTIAL-RESTRICTED WHEN * COMBINED WITH THE * * * AGGREGATED OCO SOURCE MODULES FOR THIS PROGRAM) * * * * MODULE NAME: sqlcpreq * * * * COMPONENT NAME: Distributed Data Services * * JRA data stream requestor * * * * LPP NAME: Gemstone * * * * DESCRIPTIVE NAME: Construct JRA requestor datastream * * * * COPYRIGHT: program-number (C) COPYRIGHT IBM CORP 1991* * * * STATUS: Development Phase * * * * FUNCTION: * * このモジュールはJRA データストリームを構成し、サーバ * に送信する関数の集合を含む。 * ************************************************************/ #define LINT_ARGS 1 #include "sqlz.h" #include "sqlo.h" #include "sqlocall.h" #include "sqlenv.h" #include "sqljacb.h" #include "sqljra.h" #include "sqljrai.h" #include "sqler.h" #include "sqlra.h" #include "sqlca.h" #include "sqlcc.h" #include "sqlcm.h" #include "sqlcmi.h" #include "sqle.h" #include "sqlei.h" #include "sqltc.h" #include "sqlchdda.h" #include "sqlc.h" #include "sqlci.h" #include "sqlcodes.h" #include "sqlda.h" #include "sql.h" #include "sqlcitoh.h" #include "sqlcpccb.h" #include "sqltc.h" #include "sqlcpcom.h" #include "sqlcpreq.h" /************************************************************/ /* SQLCPSND: */ /* Function: JRA データストリームを構成し、サーバに送信 */ /* Input: */ /* Pointer to ddsacb */ /* Pointer to dcsra */ /* Output: */ /* The output SQLDA pointed by the dcsra */ /************************************************************/ int SQLZ_LOCAL sqlcpsnd (struct sqlcacb *ddsacb, SQLJDSRA *dcsra) { unsigned int loc; /*com buffer位置ポインタ */ int i: /*ループカウンタ */ short buffer_len; /*com bufferの長さ * SQLJDATA *triplet; /*現在のtriplet ポインタ */ char *combuf; /*comm buffer ポインタ*/ struct sqlcplen *dslenptr; /* com buffer のストリーム長さ構造体を 指すポインタ */ /* input sqlvar の実際の長さ */ /*割り振られたstatic */ unsigned long sqlvar_actlen_in[STATIC_VARS]; unsigned long *act_len_in; /* input sqlvar の実際の長さ*/ /*実際の長さ配列が input DA に 割り振られたか否かを示すフラグ */ unsigned short alloc_flag_in = 0; unsigned long jra_parm_len = 0; /*JRA パラメータの長さ*/ unsigned int da_size; /*DAのサイズ */ unsigned int out_da_size = 0; /*output DA のサイズ*/ struct sqlda *in_da; /*input DAポインタ */ struct sqlda *out_da = NULL; /*output DA ポインタ */ struct sqlca *ca_ptr; /*SQLCA ポインタ */ struct sqlvar *sqlvar; struct sqlda *run_da= NULL; /*run stat索引リストをストアするために 割り振られたSQLDA */ struct sqlda *useroutda; /*ユーザ output da */ char *index_ptr; /* runstatの索引名 */ unsigned int run_da_size; /*runstat のために割り振られたDAサイズ*/ short no_index; /*runstat 索引の数 */ /*次の変数はカーソルオペレーションのため のものである。 */ struct sqlcp_ccb *temp_ccb; SQLJDSRA *comra; /* com buffer のJRA */ int retcode = 0; int err_retcode = 0; /*ポジティブエラー戻りコード */ short zero = 0; /************************************************************ The communication buffer(s) contain the following in order --------------------------------------------- ｜ll｜sqljra｜control structure length｜input data length --------------------------------------------- ｜output data length｜Array of input sqlvar actual length --------------------------------------- ｜JRA parm length JRA parm｜Input SQLDA ｜Output SQLDA | --------------------------------------------- ｜Input data length ************************************************************ / in_da = (struct sqlda *)dcsra->sqlrdapi; /*空間を一時 output daに割り振り、 userdaをコピーする*/ useroutda = (struct sqlda *)dcsra->sqlrdapo; /* com buffer アドレスをピックアップ */ combuf = ddsacb->buffer; comra = (SQLJDSRA *)(combuf + loc); /* com buffer のRAを指す*/ /* dcsraを com buffer にコピー*/ sqlzmcpy((char *)(combuf +loc), dcsra, JRASIZE); /*ブロッキングされた取り出しで ある場合、com bufferのoutput da 長さを 0にする*/ if (req_blocking) { comra->sqlrdaol = 0L; } /*バッファの次のポジションを指す*/ loc += JRASIZE; /*データストリーム長さ構造体を指す*/ dslenptr = (struct sqlcplen *)(combuf + loc); /*制御構造体の長さを初期設定*/ if ((in_da != 0) && (!req_compile) && (!req_runstat)) { dslenptr->cs_len = JRASIZE + SQLCPLEN_SIZE(in_da->sqld); } else dslenptr->cs_len = JRASIZE + SQLCPLEN_SIZE(0); dslenptr->in_data_len = 0; dslenptr->out_data_len = 0; /* compile 要求タイプのiput data を無視 */ if (in_da != 0 && (!req_compile) && (!req_runstat)) { dslenptr->num_of_vars = in_da->sqld; } else { dslenptr->num_of_vars = 0; } /* output SQLVARの数を設定*/ if (out_da != NULL) { dslenptr->num_of_out_vars = out_da->sqld; } else { dslenptr->num_of_out_vars = 0; } loc += SQLCPLEN_SIZE(0); /* input sqlvar の長さの配列 */ triplet = (SQLJDATA *)&(dcsra->sqlrflgl); /* 合計jra パラメータの長さをget */ /*JRA パラメータは全てが第１com buffer にないかもしれないので、第１com buffer が送信される前に、パラメータ長さをget しなければならない*/ for (i = 0; i < MAX_JRA_TRIPLET; i++) { /* 合計JRA パラメータ長さを更新する */ jra_parm_len += triplet->sqlrdtl; triplet++; /*次のトリプレットを指す*/ } /*endfor*/ dsienptr->cs_len += jra_parm_len; /*合計jra パラメータ長さを制御 構造体長さに加算する */ /*各sqlvarの実際のデータ長さと 合計input data長さをget する ためinput DAをスキャンする*/ /* JRA要求タイプがcompile である 場合、input dataをスキップする*/ /* データタイプが null になる ことができる場合、2 bytes を 実際のデータ長さに加算する*/ if ((in_da != NULL) && (!req_compile) && (!req_runstat)) { for (i = 0; i < in_da->sqld; i++) { sqlvar = &(in_da->sqlvar[i]); if (SQLV_IND_EXISTS(sqlvar) && (*(sqlvar->sqlind) < 0)) { act_len_in[i] = 0; } else { act_len_in[i] = (unsigned long) sqlcpdls(sqlvar); } if ((sqlvar->sqltype & SQL_TYP_NULINC) != 0) { dslenptr->in_data_len += SQLC_SHORT_SIZE; } dslenptr->in_data_len += act_len_in[i]; } /* endfor */ } /*end in_da check */ /* 合計output data 長さをget するため output DA をスキャン*/ /*取り出しおよびブロッキングである場合、 このコードをスキップ */ if (out_da != NULL && !req_blocking) { for (i = 0; i < out_da->sqld; i++) { sqlvar = &(out_da->sqlvar[i]); dslenptr->out_data_len += (unsigned long) sqlcpdlr(sqlvar); /*データタイプのnullが可能であり、 かつ、null識別子がnullでない場合、 空間をnull識別子に割り振るように 要求する */ if (((sqlvar->sqltype & SQL_TYP_NULINC) != 0)&& (sqlvar->slqind != NULL)) { dslenptr->out_data_len += SQLC_SHORT_SIZE; } /* null 識別子が存在する場合は、null 識別子に-1をセットし、存在しない場 合は、null識別子に０をセットする */ if (sqlvar->sqlind == NULL) { sqlvar->sqlind = (short *) -1; } else { sqlvar->sqlind = (short *) 0; } }/* endfor */ } /* dslenptr により指される全長さ 情報がセットされる。長さ配列を データストリームに移動。通信エ ラーが生じた場合、終了する。*/ if (in_da != NULL && (!req_compile) && (!req_runstat)) { err_retcode = sqlcpmd(ddsacb, &loc, (char *)act_len_in, sizeof(long)*(in_da->sqld), ca_ptr); if (err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } /************************************************************/ /* JRA パラメータデータストリームを作成 */ /************************************************************/ /*第１JRA triplet を指す */ triplet = (SQLJDATA *)&(dcsra->sqlrflgl); /*全triplet に対するループ */ for (i = 0; i < MAX_JRA_TRIPLET; i++) { /* JRAパラメータをデータストリームに移動*/ if(triplet->sqlrdtl > 0) { err_retcode = sqlcpmd(ddsacb, &loc, triplet->sqlrdtp, (unsigned int)triplet->sqlrdtl, ca_ptr); if (err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } triplet++; } /* endfor */ /************************************************************/ /* SQLJRAおよびパラメータを通信バッファにput */ /************************************************************/ /************************************************************/ /* input DA をデータストリームに移動 */ /************************************************************/ if (dcsra->sqlrdapi != NULL) { /*DAのサイズを計算 */ da_size = SQLDASIZE(((struct sqlda *)dcsra->sqlrdapi)->sqld); /* DA をcom bufferに移動*/ err_retcode = sqlcpmd(ddsacb, &loc, (char *)(dcsra->sqlrdapi), da_size, ca_ptr); if(err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } /*End sqlrdapi check */ /************************************************************/ /* output DA をデータストリームに移動 */ /************************************************************/ if ((out_da != NULL) && (!req_blocking)) { /* DA をcom bufferに移動 */ err_retcode = sqlcpmd(ddsacb, &loc, (char *)out_da, out-da_size,ca_ptr); if(err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } /* End sqlrdapo check */ /************************************************************/ /* input data をデータストリームにput */ /************************************************************/ /*input data が存在し、かつ、JRA 要求タイプがcompile でなく、かつ、 runstat でない場合 */ if ((in_da != NULL) && (!req_compile) && (!req_runstat)) { i = 0; /* 全sqlvarに対するループ */ while ((ca_ptr->sqlcode == SQL_RC_OK) && (i < in_da->sqld)) { /*次の SQLVAR をget*/ sqlvar = &(in_da->sqlvar[i]; /*データタイプをnullにできる場合、 null識別子内容をデータストリーム に送信*/ if ((sqlvar->sqltype & SQL_TYP_NULINC) != 0) { if ((sqlvar->sqlind != NULL ) && ((short)*(sqlvar->sqlind) != 0)) { err_retcode = sqlcpmd(ddsacb, &loc, (char *)(in_da->sqlvar[i].sqlind), SQLC_SHORT_SIZE, ca_ptr); } else { err_retcode = sqlcpmd(ddsacb, &loc, (char *)&zero, SQLC_SHORT_SIZE,ca_ptr); } if (err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } /* データをデータストリームに移動 */ if(act_len_in[i] > 0) { err_retcode = sqlcpmd(ddsacb, &loc, sqlvar->sqldata, (unsigned int)act_len_in[i],ca_ptr); if(err_retcode == SQLJR_RCF_TERMINATE) { goto exit; } } i++; } /* endwhile */ } /* end compile request type check */ /*com buffer内の残りのデータを処理 */ if ((ca_ptr->sqlcode == SQL_RC_OK) && (loc > SQLC_SHORT_SIZE)) { /* 長さをバッファにストア */ /*バイト逆転*/ buffer_len = SQLC_SWAP2(loc); sqlzmcpy(ddsacb->buffer, &buffer_len, SQLC_SHORT_SIZE); /* 送信 */ retcode = sqlccsen(&ddsacb->comhandle, (short)loc, ddsacb->buffer); if (retcode < 0) { sqlcperc(&ddsacb->comhandle, ca_ptr, "SQLCPREQ"); err_retcode |= SQLJR_RCF_TERMINATE; goto exit; } } /* End of sqlcode and loc check */ /************************************************************/ /* Cleaning things up */ /************************************************************/ exit: /* 一時daを解放 */ if (out-da != NULL) { retcode = sqlofblk(ddsacb->rsheap, out_da_size, out_da); /* 解放時にエラーが発生した場合、終了 */ if (retcode != 0) { sqlcpsca(ca_ptr, "SQLCPREQ", (long)SQL_RC_E902); err_retcode |= SQLJR_RCF_SQLCA; } } /* input DA に動的に割り振られた実際 の長さ配列を解放 */ if (alloc_flag_in > 0) { retcode = sqlofblk(ddsacb->rsheap, sizeof(long) *in_da->sqld, act_len_in); /* 解法時にエラーが発生した場合、終了*/ if (retcode != 0) { sqlcpsca(ca_ptr, "SQLCPREQ", (long)SQL_RC_E902); err_retcode |= SQLJR_RCF_SQLCA; } } /*End if on free block check */ /*run statに割り振られたda空間を解放*/ if (run_da != NULL) { retcode = sqlofblk(ddsacb->rsheap, run_da_size, run_da); if (retcode != 0) { sqlcpsca(ca_ptr, "SQLCPREQ", (long)SQL_RC_E902); err_retcode |= SQLJR_RCF_SQLCA; } } return(err_retcode); } 以上、特定システム環境での本発明に係る好ましい実施
例を説明したが、他のハードウェアおよび異なるハード
ウェアと、ソフトウェア環境とで、本発明の精神および
範囲を逸脱することなく、修正を行い、実施することが
できることは当業者にとって当然である。

【００４６】

【発明の効果】以上説明したように、本発明によれば、
上記のように構成したので、動的バッファリングを行っ
てデータベースサーバを拡張することができる。

【図面の簡単な説明】

【図１】本発明に係るパーソナルコンピュータシステム
を示すブロック図である。

【図２】本発明に係る遠隔データ要求のシステム制御フ
ローの一例を示すフローチャートである。

【図３】本発明に係るロジックを詳細に示すフローチャ
ートである。

【図４】本発明に係るデータ構造体を示すブロック図で
ある。

【図５】本発明に係るサーバのデータ構造体再構成ルー
チンを示すフローチャートである。

【図６】本発明に係る動的バッファロジックの一例を示
す図である。

【符号の説明】

１０ 中央処理装置 １２ システムバス １４ ＲＡＭ １６ ＲＯＭ １８ I/O アダプタ ２０ ディスク装置 ２２ ユーザインタフェースアダプタ ２４ キーボード ２６ マウス ２８ スピーカ ３２ マイクロフォン ３４ 通信アダプタ ３６ ディスプレイアダプタ ３８ ディスプレイ

フロントページの続き (72)発明者 ロイド ユージン ジョーダン ザ セカ ンド アメリカ合衆国 78729 テキサス州 オ ースティン ベイスウォーター ガーデン 13505 (72)発明者 ショウ−ベン シ アメリカ合衆国 78726 テキサス州 オ ースティン クロスランド ドライブ 11033 (72)発明者 マーティン ジェイ サーキン アメリカ合衆国 テキサス州 オースティ ン ユッカ ドライブ 10506 (72)発明者 ポール エドウィン スティーブンス アメリカ合衆国 78613 テキサス州 シ ーダー パーク サビナル トレイル 2706

Claims (7)

【特許請求の範囲】
1. 【請求項１】 第２コンピュータのデータベースからの
   情報を割り当てる際に用いるため、第１コンピュータの
   メモリ内でデータ構造体を構成する装置であって、 (a) メモリ要件データ構造体を前記第１コンピュータか
   ら獲得する獲得手段と、 (b) 前記データベースからの前記メモリ要件データ構造
   体と情報を含む通信バッファを構成する第１構成手段
   と、 (c) データベースからの情報のサイズが１つの通信バッ
   ファのサイズを超える場合、データベースからの情報を
   含む別の通信バッファを構成する第２構成手段と、 (d) 少なくとも１つの通信バッファを前記第２コンピュ
   ータに送信する送信手段と、 (e) 少なくとも１つの通信バッファを前記第２コンピュ
   ータで受信する受信手段と、 (f) 前記通信バッファ内のメモリ要件データ構造体を照
   会する照会手段と、 (g) データベースからの情報を１つの通信バッファに収
   めることができない場合、連続記憶域を割り振る割振り
   手段と、 (h) 前記情報を受信するため前記連続記憶域にポインタ
   を動的に調整する調整手段とを備えたことを特徴とする
   装置。
2. 【請求項２】 請求項１に記載の装置において、 最小の変換で通信バッファを構成する構成手段を含むこ
   とを特徴とする装置。
3. 【請求項３】 請求項２に記載の装置において、 ポインタを再割り当てし、通信バッファ内のメモリ要件
   データ構造体にアクセスするアクセス手段を含むことを
   特徴とする装置。
4. 【請求項４】 第２コンピュータのデータベースからの
   情報を割り当てる際に用いるため、第１コンピュータの
   メモリのデータ構造体を構成する方法であって、 (a) メモリ要件データ構造体を前記第１コンピュータか
   ら獲得する獲得ステップと、 (b) 前記データベースからの前記メモリ要件データ構造
   体と情報を含む通信バッファを構成する第１構成ステッ
   プと、 (c) データベースからの情報のサイズが１つの通信バッ
   ファのサイズを超える場合、データベースからの情報を
   含む別の通信バッファを構成する第２構成ステップと、 (d) 少なくとも１つの通信バッファを前記第２コンピュ
   ータに送信する送信ステップと、 (e) 少なくとも１つの通信バッファを前記第２コンピュ
   ータで受信する受信ステップと、 (f) 前記通信バッファ内のメモリ要件データ構造体を照
   会する照会ステップと、 (g) データベースからの情報を１つの通信バッファに収
   めることができない場合、連続記憶域を割り振る割振り
   ステップと、 (h) 前記情報を受信するため前記連続記憶域にポインタ
   を動的に調整する調整ステップとを備えたことを特徴と
   する装置。
5. 【請求項５】 請求項４に記載の装置において、 最小の変換で通信バッファを構成する構成ステップを含
   むことを特徴とする方法。
6. 【請求項６】 請求項５に記載の装置において、 ポインタを再割り当てし、通信バッファ内のメモリ要件
   データ構造体にアクセスするアクセスステップを含むこ
   とを特徴とする方法。
7. 【請求項７】 第１コンピュータ内の装置であり、か
   つ、第２コンピュータに駐在するデータベースにアクセ
   スする装置であって、 (a) 前記第２コンピュータ上で実行するように設計され
   たデータベース照会を作成する作成手段と、 (b) 前記第２コンピュータ上で実行するように設計され
   た前記データベース照会を含む通信バッファを前記第１
   コンピュータ上で生成する生成手段と、 (c) 前記通信バッファを前記第２コンピュータに送信す
   る第１送信手段と、 (d) 前記通信バッファを前記第２コンピュータで受信す
   る第１受信手段と、 (e) 前記第２コンピュータ上で実行するように設計され
   たデータベース照会を実行する実行手段と、 (f) 前記データベース照会の結果を前記通信バッファに
   ストアするストア手段と、 (g) 前記通信バッファを前記第１コンピュータに送信す
   る第２送信手段と、 (h) 前記通信バッファを前記第１コンピュータで受信す
   る第２受信手段とを備えたことを特徴とする装置。