sedna 0.5.1 → 0.6.0

data/vendor/sedna/driver/c/libsedna.h

@@ -0,0 +1,199 @@
+/*
+ * File:  libsedna.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+#ifndef _LIBBASE_H
+#define _LIBBASE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#endif
+
+#include <stdio.h>
+#include "sp_defs.h"
+
+
+#define QUERY_EXECUTION_TIME                       1024
+#define BULK_LOAD_PORTION                         (SE_SOCKET_MSG_BUF_SIZE-5)
+
+
+#define SEDNA_OPERATION_SUCCEEDED                 (-1)
+
+#define SEDNA_SESSION_OPEN                          1
+#define SEDNA_SESSION_CLOSED                        2
+#define SEDNA_AUTHENTICATION_FAILED               (-3)
+#define SEDNA_OPEN_SESSION_FAILED                 (-4)
+#define SEDNA_CLOSE_SESSION_FAILED                (-5)
+
+#define SEDNA_QUERY_SUCCEEDED                       6
+#define SEDNA_QUERY_FAILED                        (-7)
+
+#define SEDNA_UPDATE_SUCCEEDED                      8
+#define SEDNA_UPDATE_FAILED                       (-9)
+
+#define SEDNA_BULK_LOAD_SUCCEEDED                  10
+#define SEDNA_BULK_LOAD_FAILED                   (-11)
+
+#define SEDNA_BEGIN_TRANSACTION_SUCCEEDED          12
+#define SEDNA_BEGIN_TRANSACTION_FAILED           (-13)
+
+#define SEDNA_ROLLBACK_TRANSACTION_SUCCEEDED       14
+#define SEDNA_ROLLBACK_TRANSACTION_FAILED        (-15)
+
+#define SEDNA_COMMIT_TRANSACTION_SUCCEEDED         16
+#define SEDNA_COMMIT_TRANSACTION_FAILED          (-17)
+
+#define SEDNA_NEXT_ITEM_SUCCEEDED                  18
+#define SEDNA_NEXT_ITEM_FAILED                   (-19)
+
+#define SEDNA_NO_ITEM                            (-20)
+#define SEDNA_RESULT_END                         (-21)
+
+#define SEDNA_DATA_CHUNK_LOADED                    23
+
+#define SEDNA_ERROR                              (-24)
+
+
+#define SEDNA_TRANSACTION_ACTIVE                   25
+#define SEDNA_NO_TRANSACTION                       26
+
+#define SEDNA_CONNECTION_OK                        27
+#define SEDNA_CONNECTION_CLOSED                    28
+#define SEDNA_CONNECTION_FAILED                  (-29)
+
+#define SEDNA_AUTOCOMMIT_OFF                       30
+#define SEDNA_AUTOCOMMIT_ON                        31
+
+#define SEDNA_SET_ATTRIBUTE_SUCCEEDED              32
+#define SEDNA_GET_ATTRIBUTE_SUCCEEDED              33
+
+#define SEDNA_RESET_ATTRIBUTES_SUCCEEDED           34
+    
+#define SEDNA_BOUNDARY_SPACE_PRESERVE_OFF          35
+#define SEDNA_BOUNDARY_SPACE_PRESERVE_ON           36
+
+
+    
+    enum SEattr {SEDNA_ATTR_AUTOCOMMIT, 
+                 SEDNA_ATTR_SESSION_DIRECTORY, 
+                 SEDNA_ATTR_DEBUG, 
+                 SEDNA_ATTR_BOUNDARY_SPACE_PRESERVE_WHILE_LOAD, 
+                 SEDNA_ATTR_CONCURRENCY_TYPE, 
+                 SEDNA_ATTR_QUERY_EXEC_TIMEOUT,
+                 SEDNA_ATTR_LOG_AMMOUNT,
+                 SEDNA_ATTR_MAX_RESULT_SIZE};
+    
+    typedef void (*debug_handler_t)(enum se_debug_info_type, const char *msg_body);
+    
+    struct conn_bulk_load
+    {
+        char bulk_load_started;
+        char doc_name[SE_MAX_DOCUMENT_NAME_LENGTH+1];
+        char col_name[SE_MAX_COLLECTION_NAME_LENGTH+1];
+    };
+    
+    struct SednaConnection
+    {
+        char url[SE_HOSTNAMELENGTH + 1];
+        char db_name[SE_MAX_DB_NAME_LENGTH + 1];
+        char login[SE_MAX_LOGIN_LENGTH + 1];
+        char password[SE_MAX_PASSWORD_LENGTH + 1];
+        char session_directory[SE_MAX_DIR_LENGTH+1];
+#ifdef _WIN32
+        SOCKET socket;
+#else
+        int socket;
+#endif
+        int last_error;
+        char last_error_msg[SE_SOCKET_MSG_BUF_SIZE];
+        char query_time[QUERY_EXECUTION_TIME];
+
+        char socket_keeps_data;
+        char first_next;
+        char result_end;
+        char in_query;
+        struct conn_bulk_load cbl;
+
+        int isInTransaction;
+        int isConnectionOk;
+
+        char autocommit;
+
+        int local_data_length;
+        int local_data_offset;
+        char local_data_buf[SE_SOCKET_MSG_BUF_SIZE];
+
+        struct msg_struct msg;
+        
+        debug_handler_t debug_handler;
+        
+        char boundary_space_preserve;
+        int query_timeout;
+        int max_result_size;
+    };
+
+#ifdef _WIN32
+#define SEDNA_CONNECTION_INITIALIZER {"", "", "", "", "", INVALID_SOCKET, -1, "", "", 0, 0, 0, 0, {0, "", ""}, SEDNA_NO_TRANSACTION, SEDNA_CONNECTION_CLOSED, 1, 0, 0, "", {0, 0, ""}, NULL, 0, 0, 0}
+#else
+#define SEDNA_CONNECTION_INITIALIZER {"", "", "", "", "", -1, -1, "", "", 0, 0, 0, 0, {0, "", ""}, SEDNA_NO_TRANSACTION, SEDNA_CONNECTION_CLOSED, 1, 0, 0, "", {0, 0, ""}, NULL, 0, 0, 0}
+#endif
+
+    int SEconnect(struct SednaConnection *conn, const char *host, const char *db_name, const char *login, const char *password);
+
+    int SEclose(struct SednaConnection *conn);
+
+    int SEbegin(struct SednaConnection *conn);
+
+    int SErollback(struct SednaConnection *conn);
+
+    int SEcommit(struct SednaConnection *conn);
+
+/*query_file - file with a query*/
+    int SEexecuteLong(struct SednaConnection *conn, const char* query_file_path);
+
+    int SEexecute(struct SednaConnection *conn, const char *query);
+
+/*returns number of bytes actually read to the buffer*/
+/* 0 - if there is no data to read*/
+/* negative if error (use SEgetLastErrorMsg then))*/
+
+    int SEgetData(struct SednaConnection *conn, char *buf, int bytes_to_read);
+
+/* returns SEDNA_DATA_SENT if chunk of data was sent successfully*/
+/* SEDNA_ERROR if there was errors*/
+    int SEloadData(struct SednaConnection *conn, const char *buf, int bytes_to_load, const char *doc_name, const char *col_name);
+
+/* returns SEDNA_BULK_LOAD_FAILED or SEDNA_BULK_LOAD_SUCCEEDED (or SEDNA_ERROR)*/
+    int SEendLoadData(struct SednaConnection *conn);
+
+    int SEnext(struct SednaConnection *conn);
+
+    int SEgetLastErrorCode(struct SednaConnection *conn);
+
+    const char *SEgetLastErrorMsg(struct SednaConnection *conn);
+
+    int SEconnectionStatus(struct SednaConnection *conn);
+
+    int SEtransactionStatus(struct SednaConnection *conn);
+
+    const char *SEshowTime(struct SednaConnection *conn);
+
+    int SEsetConnectionAttr(struct SednaConnection *conn, enum SEattr attr, const void* attrValue, int attrValueLength);
+
+    int SEgetConnectionAttr(struct SednaConnection *conn, enum SEattr attr, void* attrValue, int* attrValueLength);
+    
+    int SEresetAllConnectionAttr(struct SednaConnection *conn);
+
+	void SEsetDebugHandler(struct SednaConnection *conn, debug_handler_t _debug_handler_);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/sedna/driver/c/sednamt.def

@@ -0,0 +1,21 @@
+EXPORTS
+    SEconnect
+    SEclose
+    SEbegin
+    SErollback
+    SEcommit
+    SEexecuteLong
+    SEexecute
+    SEgetData
+    SEloadData
+    SEendLoadData
+    SEnext
+    SEgetLastErrorCode
+    SEgetLastErrorMsg
+    SEconnectionStatus
+    SEtransactionStatus
+    SEshowTime
+    SEsetConnectionAttr
+    SEgetConnectionAttr
+    SEresetAllConnectionAttr
+	SEsetDebugHandler

data/vendor/sedna/driver/c/sp_defs.h

@@ -0,0 +1,186 @@
+/*
+ * File:  sp_defs.h
+ * Copyright (C) 2009 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _SP_DEFS_H
+#define _SP_DEFS_H
+
+
+
+#define SE_MAX_LOGIN_LENGTH                                511
+#define SE_MAX_PASSWORD_LENGTH                             511
+#define SE_MAX_DB_NAME_LENGTH                              511
+#define SE_MAX_DOCUMENT_NAME_LENGTH                        511
+#define SE_MAX_COLLECTION_NAME_LENGTH                      511
+#define SE_MAX_DIR_LENGTH                                  255
+#define SE_HOSTNAMELENGTH                                  255
+
+#define SE_SOCKET_MSG_BUF_SIZE                             10240
+#define SE_MAX_QUERY_SIZE                                  2097152 // Maximum query size 2 Mb
+
+#define SE_CURRENT_SOCKET_PROTOCOL_VERSION_MAJOR           3
+#define SE_CURRENT_SOCKET_PROTOCOL_VERSION_MINOR           0
+
+#define SEDNA_DEBUG_OFF                                    0
+#define SEDNA_DEBUG_ON                                     1
+
+#define SEDNA_READONLY_TRANSACTION                         2
+#define SEDNA_UPDATE_TRANSACTION                           3
+
+#define SEDNA_QUERY_EXEC_TIMEOUT                           4
+#define SEDNA_MAX_RESULT_SIZE                              5
+
+#define SEDNA_LOG_AMMOUNT                                  6
+#define SEDNA_LOG_LESS                                     7
+#define SEDNA_LOG_FULL                                     8
+
+
+typedef int sp_int32;
+
+enum se_debug_info_type 
+{
+    se_QueryTrace,
+    se_QueryDebug
+};
+
+enum se_item_class
+{
+    se_atomic    = 1,
+    se_document  = 2,
+    se_element   = 3,
+    se_attribute = 4,
+    se_namespace = 5,
+    se_pi        = 6,
+    se_comment   = 7,
+    se_text      = 8
+};
+
+enum se_item_type
+{
+    /* Abstract base types */
+    se_anyType            = 0,
+    se_anySimpleType      = 1,
+    se_anyAtomicType      = 2,
+    /* Built-in simple, non-atomic types */
+    se_IDREFS             = 3,
+    se_NMTOKENS           = 4,
+    se_ENTITIES           = 5,
+    /* Built-in complex types */
+    se_untyped            = 6,
+    /* Built-in atomic types (Primitive types) */
+    se_dateTime           = 10,
+    se_date               = 11,
+    se_time               = 12,
+    se_duration           = 13,
+    se_yearMonthDuration  = 14,
+    se_dayTimeDuration    = 15,
+    se_gYearMonth         = 16,
+    se_gYear              = 17,
+    se_gMonthDay          = 18,
+    se_gDay               = 19,
+    se_gMonth             = 20,
+    se_float              = 21,
+    se_double             = 22,
+    se_decimal            = 23,
+    se_integer            = 24,
+    se_boolean            = 25,
+    se_untypedAtomic      = 26,
+    se_string             = 27,
+    se_base64Binary       = 28,
+    se_hexBinary          = 29,
+    se_anyURI             = 30,
+    se_QName              = 31,
+    se_NOTATION           = 32,
+    /* Types derived from xs:string */
+    se_normalizedString   = 41,
+    se_token              = 42,
+    se_language           = 43,
+    se_NMTOKEN            = 44,
+    se_Name               = 45,
+    se_NCName             = 46,
+    se_ID                 = 47,
+    se_IDREF              = 48,
+    se_ENTITY             = 49,
+    /* Types derived from xs:integer */
+    se_nonPositiveInteger = 50,
+    se_negativeInteger    = 51,
+    se_long               = 52,
+    se_int                = 53,
+    se_short              = 54,
+    se_byte               = 55,
+    se_nonNegativeInteger = 56,
+    se_unsignedLong       = 57,
+    se_unsignedInt        = 58,
+    se_unsignedShort      = 59,
+    se_unsignedByte       = 60,
+    se_positiveInteger    = 61
+};
+
+
+enum se_sp_instructions
+{   
+    se_ErrorResponse = 100,
+    se_StartUp = 110,
+    se_SessionParameters = 120,
+    se_AuthenticationParameters = 130,
+    se_SendSessionParameters = 140,
+    se_SendAuthParameters = 150,
+    se_AuthenticationOK = 160,
+    se_AuthenticationFailed = 170,
+    se_BeginTransaction = 210,
+    se_CommitTransaction = 220,
+    se_RollbackTransaction = 225,
+    se_BeginTransactionOk = 230,
+    se_BeginTransactionFailed = 240,
+    se_CommitTransactionOk = 250,
+    se_CommitTransactionFailed = 260,
+    se_RollbackTransactionOk = 255,
+    se_RollbackTransactionFailed = 265,
+    se_Execute = 300,
+    se_ExecuteLong = 301,
+    se_LongQueryEnd = 302,
+    se_GetNextItem = 310,
+    se_QuerySucceeded = 320,
+    se_DebugInfo = 325,
+    se_QueryFailed = 330,
+    se_UpdateSucceeded = 340,
+    se_UpdateFailed = 350,
+    se_ItemStart = 355,
+    se_ItemPart = 360,
+    se_ItemEnd = 370,
+    se_ResultEnd = 375,
+    se_BulkLoadError = 400,
+    se_BulkLoadPortion = 410,
+    se_BulkLoadEnd = 420,
+    se_BulkLoadFileName = 430,
+    se_BulkLoadFromStream = 431,
+    se_BulkLoadSucceeded = 440,
+    se_BulkLoadFailed = 450,
+    se_ShowTime = 451,
+    se_LastQueryTime = 452,
+    se_CloseConnection = 500,
+    se_CloseConnectionOk = 510,
+    se_TransactionRollbackBeforeClose = 520,
+    se_Authenticate = 90,
+    se_ExecuteSchemeProgram = 95,
+    se_SetSessionOptions = 530,
+    se_SetSessionOptionsOk = 540,
+    se_ResetSessionOptions = 550,
+    se_ResetSessionOptionsOk = 560
+};
+
+struct msg_struct
+{
+    sp_int32 instruction;
+    sp_int32 length;
+    char body[SE_SOCKET_MSG_BUF_SIZE];
+};
+
+struct protocol_version{
+	char major_version;
+	char minor_version;
+};
+
+
+#endif /* _SP_DEFS_H */

data/vendor/sedna/kernel/common/FastXptrHash.cpp

@@ -0,0 +1,101 @@
+
+#include "common/FastXptrHash.h"
+
+#define MAGIC_NUMBER 2654435761UL
+#define CS_CELL_COUNT 256
+#define CS_CELL_SIN_BITS 8
+
+#define hashSize 1024
+//const uint16_t hashSize = 32;
+
+struct SecondLayer {
+    SecondLayer * next;
+    const xptr block;
+    void * values[CS_CELL_COUNT];
+
+    inline uint32_t hash(const xptr &a) {
+        return (uint32_t) ((a.to_uint64() >> CS_CELL_SIN_BITS) & CS_CELL_COUNT);
+    }
+
+    inline SecondLayer(const xptr &a) : block(a), next(NULL) {
+        memset(&(this->values), 0, sizeof(void *) * CS_CELL_COUNT);
+    };
+
+    inline ~SecondLayer() { };
+
+    inline void * get(const xptr &a) const {
+        return values[hash(a)];
+    };
+
+    inline void set(const xptr &a, void * v) {
+        values[hash(a)] = v;
+    };
+};
+
+class RealHashTable {
+private:
+    SecondLayer * buckets[hashSize];
+
+    inline uint32_t hash(const xptr &a) {
+      return ((uint32_t) ((a.to_uint64() >> PAGE_BIT_SIZE) & 0xffffffff) * MAGIC_NUMBER) % hashSize;
+    }
+public :
+    inline RealHashTable() {
+        memset(&(this->buckets), 0, sizeof(SecondLayer *) * hashSize);
+    };
+
+    inline ~RealHashTable() {
+        for (int i = 0; i < hashSize; i++) {
+            while (buckets[i] != NULL) {
+                SecondLayer * b = buckets[i];
+                buckets[i] = b->next;
+                b->~SecondLayer();
+                free(b);
+            }
+        }
+    };
+
+    inline void * get(const xptr &a) const {
+        SecondLayer * b = buckets[hash(a)];
+        while ((b != NULL) && (b->block != BLOCKXPTR(a))) { b = b->next; }
+
+        if (b == NULL) { return NULL; }
+        else { return b->get(a); }
+    };
+
+    inline void set(const xptr &a, void * v) {
+        uint32_t bi = hash(a);
+        SecondLayer * b = buckets[bi];
+        while ((b != NULL) && (b->block != BLOCKXPTR(a))) { b = b->next; }
+
+        if (b == NULL) {
+
+            b = new (malloc(sizeof(SecondLayer))) RealHashTable;
+
+            b->next = buckets[bi];
+            buckets[bi] = b;
+        };
+
+        b->set(a, v);
+    };
+};
+
+
+FastCatalogXptrHash::FastCatalogXptrHash() {
+    this->topLayer = new (malloc(sizeof(RealHashTable))) RealHashTable(BLOCKXPTR(a));
+};
+
+FastCatalogXptrHash::~FastCatalogXptrHash() {
+    this->topLayer::~RealHashTable();
+    free(this->topLayer);
+};
+
+void * FastCatalogXptrHash::get(const xptr &a) const
+{
+    return this->topLayer->get(a);
+};
+
+void FastCatalogXptrHash::set(const xptr &a, const void *v)
+{
+    this->topLayer->set(a, v);
+};