transactd 2.0.1 → 2.1.0

data/source/bzs/db/protocol/tdap/client/errorMessage_ja.cpp

@@ -1,4 +1,4 @@
-/*=================================================================
+/*=================================================================
    Copyright (C) 2000-2013 BizStation Corp All rights reserved.
 
    This program is free software; you can redistribute it and/or
@@ -40,139 +40,139 @@ PACKAGE _TCHAR* getErrorMessageLocale(int errorCode, _TCHAR* buf, size_t size)
     case STATUS_LOCK_ERROR:
     case STATUS_FILE_LOCKED:
     case STATUS_CANNOT_LOCK_TABLE:
-        p = _T("���̃��R�[�h�͊��ɑ��̃��[�U�[�ɂ�胍�b�N����Ă��܂��B");
+        p = _T("このレコードは既に他のユーザーによりロックされています。");
         break;
     case STATUS_CHANGE_CONFLICT:
-        p = _T("���̃��R�[�h�͍��A���̃��[�U�[�ɂ��ύX����܂����B");
+        p = _T("このレコードは今、他のユーザーにより変更されました。");
         break;
     case STATUS_TABLE_YET_OPEN:
-        p = _T("���̃e�[�u���͂܂� OPEN ����Ă��܂���B");
+        p = _T("このテーブルはまだ OPEN されていません。");
         break;
     case STATUS_DURING_TRANSACTION:
-        p = _T("���̃e�[�u���͂܂��g�����U�N�V�������ł��Bclose �ł��܂���B");
+        p = _T("このテーブルはまだトランザクション中です。close できません。");
         break;
     case STATUS_NO_ACR_UPDATE_DELETE:
-        p = _T("�X�V�܂��͍폜�A�N�Z�X��������܂���B");
+        p = _T("更新または削除アクセス権がありません。");
         break;
     case STATUS_NO_ACR_INSERT:
-        p = _T("�lj��A�N�Z�X��������܂���B");
+        p = _T("追加アクセス権がありません。");
         break;
     case STATUS_NO_ACR_READ:
-        p = _T("�ǂݎ��A�N�Z�X��������܂���B");
+        p = _T("読み取りアクセス権がありません。");
         break;
     case STATUS_CANT_ALLOC_MEMORY:
-        p = _T("���������m�ۂł��܂���ł����B");
+        p = _T("メモリが確保できませんでした。");
         break;
     case STATUS_USE_KEYFIELD:
-        p = _T("���̃t�B�[���h�̓L�[�Ŏg�p����Ă��邽�ߍ폜�ł��܂���B");
+        p = _T("このフィールドはキーで使用されているため削除できません。");
         break;
     case STATUS_TOO_MANY_TABLES:
-        p = _T("�Ǘ��”\�ȃe�[�u�����𒴂��Ă��܂��B");
+        p = _T("管理可能なテーブル数を超えています。");
         break;
     case STATUS_INVARID_PRM_KEY_NUM:
-        p = _T("MainKey�L�[�ԍ����s���ł��B");
+        p = _T("MainKeyキー番号が不正です。");
         break;
     case STATUS_INVARID_PNT_KEY_NUM:
-        p = _T("ParentKey�L�[�ԍ����s���ł��B");
+        p = _T("ParentKeyキー番号が不正です。");
         break;
     case STATUS_INVARID_REP_KEY_NUM:
-        p = _T("ReplicaKey�L�[�ԍ����s���ł��B");
+        p = _T("ReplicaKeyキー番号が不正です。");
         break;
     case STATUS_INVARID_FIELD_IDX:
-        p = _T("�t�B�[���h�C���f�b�N�X���L���͈͂ɂ���܂���B");
+        p = _T("フィールドインデックスが有効範囲にありません。");
         break;
     case STATUS_ALREADY_DELETED:
-        p = _T("���̃A�C�e���͍폜����Ă��܂��B");
+        p = _T("このアイテムは削除されています。");
         break;
     case STATUS_LMITS_MAX_TABLES:
-        p = _T("�I�[�v���ł���e�[�u���̍ő吔�𒴂��Ă��܂��B");
+        p = _T("オープンできるテーブルの最大数を超えています。");
         break;
     case STATUS_DB_YET_OPEN:
-        p = _T("�f�[�^�x�[�X���I�[�v������Ă��܂���B");
+        p = _T("データベースがオープンされていません。");
         break;
     case STATUS_TABLENAME_NOTFOUND:
-        p = _T("�w�肵���e�[�u���������‚���܂���B");
+        p = _T("指定したテーブル名が見つかりません。");
         break;
     case STATUS_DIFFERENT_DBVERSION:
-        p = _T("�f�[�^�x�[�X�̃o�[�W�������Ⴄ���A�j�����Ă��܂��B");
+        p = _T("データベースのバージョンが違うか、破損しています。");
         break;
     case STATUS_DUPLICATE_FIELDNAME:
-        p = _T("�t�B�[���h�����d�����Ă��܂��B");
+        p = _T("フィールド名が重複しています。");
         break;
     case STATUS_INVALID_TABLE_IDX:
-        p = _T("��`����Ȃ��e�[�u���ԍ��ł��B");
+        p = _T("定義されないテーブル番号です。");
         break;
     case STATUS_AUTH_DENIED:
-        p = _T("���[�U�[���܂��̓p�X���[�h���s���ł��B");
+        p = _T("ユーザー名またはパスワードが不正です。");
         break;
     case STATUS_TOO_MANY_FIELDS:
-        p = _T("�Ǘ��”\�ȃt�B�[���h���𒴂��Ă��܂��B");
+        p = _T("管理可能なフィールド数を超えています。");
         break;
     case STATUS_FILTERSTRING_ERROR:
-        p = _T("�t�B���^������Ɍ�肪����܂��B");
+        p = _T("フィルタ文字列に誤りがあります。");
         break;
     case STATUS_INVALID_FIELDLENGTH:
-        p = _T("�t�B�[���h�����s���ł��B");
+        p = _T("フィールド長が不正です。");
         break;
     case STATUS_INVALID_KEYTYPE:
-        p = _T("�g�p�ł��Ȃ��L�[�^�C�v���w�肳��Ă��܂��B");
+        p = _T("使用できないキータイプが指定されています。");
         break;
     case STATUS_LVAR_NOTE_NOT_LAST:
-        p = _T("Note�y��Lvar�^�C�v�̓t�B�[���h�̈�ԍŌ�łȂ���΂Ȃ�܂���")
+        p = _T("Note及びLvarタイプはフィールドの一番最後でなければなりません")
             _T("B");
         break;
     case STATUS_INVALID_VARIABLETABLE:
-        p = _T("�•ϒ��e�[�u���̍Ō�̃t�B�[���h��Note Lvar ")
-            _T("varbinary�^�C�v���K�v�ł��B");
+        p = _T("可変長テーブルの最後のフィールドはNote Lvar ")
+            _T("varbinaryタイプが必要です。");
         break;
     case STATUS_NODEF_FOR_CONVERT:
-        p = _T("�R���o�[�g����`������܂���B");
+        p = _T("コンバート元定義がありません。");
         break;
     case STATUS_TRD_NEED_VARLENGTH:
-        p = _T("�•ϒ��e�[�u���̎w�肪�K�v�ł��B");
+        p = _T("可変長テーブルの指定が必要です。");
         break;
     case STATUS_TOO_LONG_OWNERNAME:
-        p = _T("�I�[�i�[�l�[�����������܂��B");
+        p = _T("オーナーネームが長すぎます。");
         break;
     case STATUS_CANT_DEL_FOR_REL:
-        p = _T("�Q�Ɛ������̂��ߍ폜�ł��܂���B");
+        p = _T("参照整合性のため削除できません。");
         break;
     case STATUS_NO_AUTOINC_SPACE:
-        p = _T("AutoIncEx�̃X�y�[�X������܂���B");
+        p = _T("AutoIncExのスペースがありません。");
         break;
     case STATUS_INVALID_RECLEN:
-        p = _T("���R�[�h����`���s�����A�e�[�u�����I�[�v������Ă��܂���B");
+        p = _T("レコード長定義が不正か、テーブルがオープンされていません。");
         break;
     case STATUS_INVALID_FIELDVALUE:
-        p = _T("�t�B�[���h�̒l���s���ł��B");
+        p = _T("フィールドの値が不正です。");
         break;
     case STATUS_INVALID_VALLEN:
-        p = _T("�•ϒ����R�[�h�̒������o�b�t�@�T�C�Y�𒴂��Ă��܂��B");
+        p = _T("可変長レコードの長さがバッファサイズを超えています。");
         break;
     case STATUS_FIELDTYPE_NOTSUPPORT:
         p = _T("This field type is not supported.");
         break;
     case STATUS_DUPPLICATE_KEYVALUE:
-        p = _T("�L�[�l���d�����Ă��邽�ߓo�^�ł��܂���B");
+        p = _T("キー値が重複しているため登録できません。");
         break;
     case STATUS_REQUESTER_DEACTIVE:
-        p = _T("�f�[�^�x�[�X�G���W�������[�h�ł��܂���B\r\nTerminal ")
-            _T("Service�y�сAWindowsXP�̃��[�U�[�؂�ւ�")
+        p = _T("データベースエンジンをロードできません。\r\nTerminal ")
+            _T("Service及び、WindowsXPのユーザー切り替え")
             _T
-			("�ɂ����āA�����ɑ����̃��[�U�[�����p����ɂ́APervasive.SQL 2000i Server�ȏ�̃C���X�g�[�����K�v�ł��B");
+			("において、同時に多数のユーザーが利用するには、Pervasive.SQL 2000i Server以上のインストールが必要です。");
         break;
     case STATUS_ACCESS_DENIED:
-        p = _T("�X�V�̂��߂̃A�N�Z�X��������܂���B\r\n�t�@�C���̓��[�h�I����")
-            _T("�[���p�X���[�h������������܂���B");
+        p = _T("更新のためのアクセス権がありません。\r\nファイルはリードオンリ")
+            _T("ーかパスワードが正しくありません。");
         break;
     case STATUS_CANT_CREATE:
-        p = _T("�f�[�^�x�[�X�̍쐬�Ɏ��s���܂����B���Ƀf�[�^�x�[�X�����݂��Ă�")
-            _T("�Ȃ����m�F���Ă��������B");
+        p = _T("データベースの作成に失敗しました。既にデータベースが存在してい")
+            _T("ないか確認してください。");
         break;
     default:
-        _stprintf_s(buf, 256, _T("�f�[�^�x�[�X�I�y���[�V�����ŃG���[����������")
-                              _T("�����B\r\n�G���[�ԍ��� %d \r\n ")
-                              _T("�����𒆎~���܂��B"),
+        _stprintf_s(buf, 256, _T("データベースオペレーションでエラーが発生しま")
+                              _T("した。\r\nエラー番号は %d \r\n ")
+                              _T("処理を中止します。"),
                     errorCode);
     }
     if (p)

data/source/bzs/db/protocol/tdap/client/field.cpp

@@ -23,8 +23,6 @@
 #include <bzs/db/protocol/tdap/fieldComp.h>
 #include "stringConverter.h"
 #include <bzs/rtl/stringBuffers.h>
-#include <boost/shared_array.hpp>
-
 #ifdef BCB_32
 #pragma option push
 #pragma option -O1
@@ -33,6 +31,7 @@
 #else
 #include <boost/unordered_map.hpp>
 #endif
+#include <boost/shared_array.hpp>
 
 #pragma package(smart_init)
 
@@ -437,7 +436,6 @@ inline void setValue(const fielddef& fd, uchar_td* ptr, __int64 value)
 void* field::ptr() const
 {
     return m_ptr + m_fd->pos;
-    ;
 }
 
 void field::setFVA(const char* data)
@@ -705,7 +703,7 @@ void field::setFV(int data)
 {
     if (!m_ptr)
         return;
-    char buf[20];
+    char buf[50];
     double d;
     int v = data;
     switch (m_fd->type)
@@ -781,7 +779,7 @@ void field::setFV(int data)
             setFVA("");
         else
         {
-            _ltoa_s(data, buf, 20, 10);
+            _ltoa_s(data, buf, 50, 10);
             setFVA(buf);
         }
         break;
@@ -795,8 +793,8 @@ void field::setFV(int data)
             setFV(_T(""));
         else
         {
-            _TCHAR buf[30];
-            _ltot_s(data, buf, 30, 10);
+            _TCHAR buf[50];
+            _ltot_s(data, buf, 50, 10);
             setFV(buf);
         }
         break;
@@ -810,7 +808,7 @@ void field::setFV(double data)
 {
     if (!m_ptr)
         return;
-    char buf[20];
+    char buf[50];
     __int64 i64;
     switch (m_fd->type)
     {
@@ -884,8 +882,8 @@ void field::setFV(double data)
             setFV(_T(""));
         else
         {
-            _TCHAR buf[40];
-            _stprintf_s(buf, 40, _T("%f"), data);
+            _TCHAR buf[50];
+            _stprintf_s(buf, 50, _T("%f"), data);
             setFV(buf);
         }
         break;
@@ -1570,8 +1568,12 @@ void* field::getFVbin(uint_td& size) const
         int sizeByte = m_fd->len - 8;
         size = 0;
         memcpy(&size, (char*)m_ptr + m_fd->pos, sizeByte);
-        char** ptr = (char**)((char*)m_ptr + m_fd->pos + sizeByte);
-        return (void*)*ptr;
+        if (size)
+        {
+            char** ptr = (char**)((char*)m_ptr + m_fd->pos + sizeByte);
+            return (void*)*ptr;
+        }
+        return NULL;
     }
     case ft_lvar:
     {
@@ -1602,7 +1604,7 @@ double field::getFVDecimal() const
     buf[len - 1] = (unsigned char)(buf[len - 1] & 0xF0);
     for (i = 0; i < len; i++)
     {
-        sprintf_s(n, 50, "%02x", buf[i]);
+        sprintf_s(n, 10, "%02x", buf[i]);
         strcat(result, n);
     }
     i = (int)strlen(result);
@@ -1978,6 +1980,13 @@ bool field::isCompPartAndMakeValue()
     return ret;
 }
 
+void field::offsetBlobPtr(size_t offset)
+{
+    int size = m_fd->blobLenBytes();
+    char** p = (char**)((char*)m_ptr + size);
+    *p += offset; 
+}
+
 } // namespace client
 } // namespace tdap
 } // namespace protocol

data/source/bzs/db/protocol/tdap/client/field.h

@@ -169,8 +169,6 @@ private:
     void setFVNumeric(double data);
     //  ---- end regacy interfaces ----  //
 
-    inline field(unsigned char* ptr, const fielddef& fd, fielddefs* fds)
-        : m_fd((fielddef*)&fd), m_ptr(ptr), m_fds(fds){};
 
 /** @cond INTERNAL */
 #if defined(SWIG) ||                                                           \
@@ -178,9 +176,14 @@ private:
 public:
 #endif
     inline field() : m_fd(NULL), m_ptr(NULL), m_fds(NULL){};
-    /** @endcond */
+/** @endcond */
 
 public:
+/** @cond INTERNAL */
+    inline field(unsigned char* ptr, const fielddef& fd, fielddefs* fds)
+        : m_fd((fielddef*)&fd), m_ptr(ptr), m_fds(fds){};
+/** @endcond */
+
     // To inline
     inline field(const field& r) : m_fd(r.m_fd), m_ptr(r.m_ptr), m_fds(r.m_fds)
     {
@@ -310,6 +313,7 @@ public:
 
     /** @cond INTERNAL */
     bool isCompPartAndMakeValue();
+    void offsetBlobPtr(size_t offset);
     /** @endcond */
 };
 

data/source/bzs/db/protocol/tdap/client/fieldDDF.cpp

@@ -111,7 +111,7 @@ void fieldDDF::createTable(const _TCHAR* fullpath)
 {
     fileSpec* fs;
     fs = (fileSpec*)malloc(512);
-    memset(fs, 512, 0x00);
+    memset(fs, 0x00, 512);
     fs->recLen = 32;
     fs->pageSize = 4096;
     fs->indexCount = 5;

data/source/bzs/db/protocol/tdap/client/fieldNameAlias.cpp

@@ -86,7 +86,6 @@ const _TCHAR* fdNmaeAlias::get(const _TCHAR* src) const
     {
         return _T("");
     }
-    return _T("");
 }
 
 const _TCHAR* fdNmaeAlias::resolv(const _TCHAR* dst) const

data/source/bzs/db/protocol/tdap/client/fieldNameAlias.h

@@ -45,6 +45,7 @@ public:
     const _TCHAR* resolv(const _TCHAR* dst) const;
     void clear();
     void reverseAliasNamesQuery(queryBase& q) const;
+
 };
 
 typedef fdNmaeAlias aliasMap_type;

data/source/bzs/db/protocol/tdap/client/fields.h

@@ -22,7 +22,6 @@
 #include "table.h"
 #include <boost/shared_ptr.hpp>
 #include <stdio.h>
-
 namespace bzs
 {
 namespace db
@@ -34,16 +33,102 @@ namespace tdap
 namespace client
 {
 
+
+/** @cond INTERNAL */
+#define MEM_ALLOC_TYPE_NONE   0
+#define MEM_ALLOC_TYPE_ONE    1
+#define MEM_ALLOC_TYPE_ARRAY  2
+
+/* This class specify memory allocation type owned. 
+   If copy this object do not copy menbers.
+   Because copy destination allocation type specify destination owned.
+*/
+class refarymem
+{
+    union
+    {
+        refarymem* m_parent;
+        int m_refCount;
+    };
+
+    bool m_child;
+    unsigned char m_allocType;
+
+    virtual void releaseMemory() = 0;
+
+protected:
+
+    refarymem(const refarymem& r):m_parent(NULL), 
+            m_child(0), m_allocType(MEM_ALLOC_TYPE_NONE){}
+
+    refarymem& operator=(const refarymem& r)
+    {
+        return *this;
+    }
+
+    inline int allocType() {return m_allocType;}
+
+public:
+
+    refarymem():m_parent(NULL), m_child(0), m_allocType(MEM_ALLOC_TYPE_NONE){}
+    
+    inline void setAllocParent(refarymem* v) 
+    { 
+        m_parent = v;
+        m_child = (v != NULL);
+    }
+    
+    void setAllocTypeThis(int v) { m_allocType = ( unsigned char)v; }
+    
+    void addref()
+    {
+        if (m_child)
+            m_parent->addref();
+        else if (m_allocType)
+            ++m_refCount;
+    }
+
+    void release()
+    {
+        if (m_child)
+            m_parent->release();
+        else
+        {
+            --m_refCount;
+            if (m_refCount == 0)
+                releaseMemory();
+        }
+    }
+    
+    int refcount() const { return m_refCount; }
+
+    bool tryFastRelease(int totalRefCount)
+    {
+        if (!m_child && (m_refCount == totalRefCount))
+        {
+            m_refCount = 1;
+            release();
+            return true;
+        }
+        return false;
+    }
+};
+/** @endcond */
+
+class autoMemory;
+
 /* copyable */
-class fieldsBase
+class fieldsBase : public refarymem
 {
     friend class multiRecordAlocatorImple;
     friend class recordsetImple;
+    friend class recordsetQuery;
+
     virtual unsigned char* ptr(int index) const = 0;
 
 protected:
     /** @cond INTERNAL */
-    fielddefs& m_fns;
+    fielddefs* m_fns;
     bool m_invalidRecord;
     virtual table* tbptr() const { return NULL; }
 
@@ -62,21 +147,21 @@ protected:
             nstable::throwError(tmp, STATUS_INVARID_FIELD_IDX);
         }
     }
-    explicit inline fieldsBase(fielddefs& fns)
-        : m_fns(fns), m_invalidRecord(false)
+    
+    explicit inline fieldsBase(fielddefs* fns)
+        : refarymem(), m_fns(fns), m_invalidRecord(false)
     {
     }
 
-    inline void setFielddefs(fielddefs& def) { m_fns = def; }
+    inline void setFielddefs(fielddefs* def) { m_fns = def; }
 
     virtual void removeLastMemBlock(){};
 
-    virtual void setRecordData(unsigned char* ptr, size_t size,
+    virtual void setRecordData(autoMemory* am, unsigned char* ptr, size_t size,
                                short* endFieldIndex, bool owner = false){};
-
     /** @endcond */
-
 public:
+
     virtual ~fieldsBase(){};
 
     inline void setInvalidRecord(bool v) { m_invalidRecord = v; }
@@ -85,45 +170,45 @@ public:
 
     inline field getFieldNoCheck(short index) const
     {
-        return field(ptr((short)index), m_fns[(short)index], &m_fns);
+        return field(ptr((short)index), (*m_fns)[(short)index], m_fns);
     }
 
     inline field operator[](short index) const
     {
-        if (m_fns.checkIndex(index))
-            return field(ptr((short)index), m_fns[(short)index], &m_fns);
+        if (m_fns->checkIndex(index))
+            return field(ptr((short)index), (*m_fns)[(short)index], m_fns);
 
         throwIndexError(index);
-        return field(NULL, dummyFd(), &m_fns);
+        return field(NULL, dummyFd(), m_fns);
     }
 
     inline field operator[](const _TCHAR* name) const
     {
-        int index = m_fns.indexByName(name);
-        return operator[](index);
+        return operator[](std::_tstring(name));
     }
 
     inline field operator[](const std::_tstring& name) const
     {
-        return operator[](name.c_str());
+        short index = m_fns->indexByName(name);
+        return operator[](index);
     }
 
-    inline size_t size() const { return m_fns.size(); }
+    inline size_t size() const { return m_fns->size(); }
 
     inline field fd(short index) const { return operator[](index); }
 
     inline field fd(const _TCHAR* name) const
     {
-        int index = m_fns.indexByName(name);
+        int index = m_fns->indexByName(name);
         return operator[](index);
     }
 
     inline short indexByName(const _TCHAR* name) const
     {
-        return m_fns.indexByName(name);
+        return m_fns->indexByName(name);
     }
 
-    inline const fielddefs* fieldDefs() const { return &m_fns; }
+    inline const fielddefs* fieldDefs() const { return m_fns; }
 
     virtual void clear() = 0;
 };
@@ -131,13 +216,15 @@ public:
 typedef boost::shared_ptr<database> database_ptr;
 typedef boost::shared_ptr<table> table_ptr;
 typedef fieldsBase row;
-typedef boost::shared_ptr<row> row_ptr;
+typedef row* row_ptr;
 
 /* copyable*/
 class fields : public fieldsBase
 {
     table& m_tb;
 
+    void releaseMemory(){}
+
     inline unsigned char* ptr(int index) const
     {
         return (unsigned char*)m_tb.data();
@@ -145,15 +232,15 @@ class fields : public fieldsBase
 
     table* tbptr() const { return &m_tb; }
 
-    inline explicit fields() : fieldsBase(*((fielddefs*)0)), m_tb(*((table*)0))
+    inline explicit fields() : fieldsBase(NULL), m_tb(*((table*)0))
     {
     }
 
 public:
-    inline explicit fields(table& tb) : fieldsBase(*(tb.m_fddefs)), m_tb(tb) {}
+    inline explicit fields(table& tb) : fieldsBase(tb.m_fddefs), m_tb(tb) {}
 
     inline explicit fields(table_ptr tb)
-        : fieldsBase(*((*tb).m_fddefs)), m_tb(*tb)
+        : fieldsBase((*tb).m_fddefs), m_tb(*tb)
     {
     }