~mordred/ndb-bindings/resultsets

// -*- mode: c++ -*- 

/*  ndb-bindings: Bindings for the NDB API

    Copyright (C) 2006 MySQL, Inc.

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or 

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

%include "typemaps.i"

%{

#include <NdbApi.hpp> 

%}

%include "ndb_constants.h"

%include "ndb_init.h"

#if defined(SWIG_PYTHON)

%init %{

ndb_init();

%}

#endif

enum AbortOption {

  CommitIfFailFree = 0,         

  TryCommit = 0,

  AbortOnError = 0,

  CommitAsMuchAsPossible = 2,

  AO_IgnoreError = 2

};

enum ExecType { 

  NoExecTypeDef = -1,

  Prepare,

  NoCommit,

  Commit,

  Rollback

};

typedef unsigned long long Uint64; 

typedef unsigned int Uint32; 

typedef signed long long Int64; 

typedef signed int Int32;

/*%include "cluster.hpp"*/

class Ndb_cluster_connection {

public:

  Ndb_cluster_connection(const char * connectstring = 0);

  ~Ndb_cluster_connection();

  %exception connect { 

    $action

      if (result) { 

	const char * msg = "Connect to management server failed"; 

#if defined(SWIGPYTHON)

        PyErr_SetString(PyExc_RuntimeError, msg); 

        return PyInt_FromLong(-1); 

#endif

#if defined(SWIGJAVA)

	jclass clazz = jenv->FindClass("java/lang/RuntimeException");

	jenv->ThrowNew(clazz, msg); 

        return -1; 

#endif 

      }

  }

  int connect(int no_retries=0, int retry_delay_in_seconds=1, int verbose=0);

  int wait_until_ready(int timeout_for_first_alive,

		       int timeout_after_first_alive);

};

%extend Ndb_cluster_connection {

public:

  Ndb* getNdb(const char* aCatalogName="", const char* aSchemaName="def") {

    Ndb* myNdb = new Ndb(self,aCatalogName,aSchemaName);

    return myNdb; 

  }

}

class Ndb { 

public:

  Ndb(Ndb_cluster_connection *ndb_cluster_connection,

      const char* aCatalogName = "", const char* aSchemaName = "def");

  ~Ndb();

  int init(int maxNoOfTransactions = 4);

  // Deprcated 

  int waitUntilReady(int timeout = 60);

  const NdbError & getNdbError() const;

  %exception startTransaction { 

    $action

      if (result==NULL) { 

        NdbError err = arg1->getNdbError();

        PyErr_SetString(PyExc_RuntimeError, err.message);

        return NULL; 

      }

  }

  NdbTransaction* startTransaction(const NdbDictionary::Table *table= 0,

				   const char  *keyData = 0, 

				   Uint32       keyLen = 0);

public:

  int getAutoIncrementValue(const char* aTableName, 

                            Uint64 & tupleId, Uint32 cacheSize);

  void closeTransaction(NdbTransaction*);

};     

%extend Ndb {

public:

  NdbTransaction* startTransaction(const char* aTableName, 

				   const char *keyData) {

    const NdbDictionary::Dictionary *myDict = self->getDictionary();

    const NdbDictionary::Table *myTable = myDict->getTable(aTableName);

    return self->startTransaction(myTable,keyData);

  }

  NdbTransaction* startTransaction(const char* aTableName, 

				   int keyData) {

    const NdbDictionary::Dictionary *myDict = self->getDictionary();

    const NdbDictionary::Table *myTable = myDict->getTable(aTableName);

    return self->startTransaction(myTable,(const char *) &keyData);

  }

  Uint64 getAutoIncrementValue(const char* aTableName,

			       Uint32 cacheSize) {

    Uint64 id = 0;

    self->getAutoIncrementValue(aTableName,id,cacheSize);

    return id;

  };

};

class NdbTransaction {

  ~NdbTransaction();

  NdbTransaction(Ndb* aNdb); 

public: 

  NdbOperation* getNdbOperation(const char* aTableName);

  NdbScanOperation* getNdbScanOperation(const char* aTableName);

  const NdbError & getNdbError() const;

  int execute(ExecType execType,

	      AbortOption abortOption = AbortOnError,

	      int force = 0 );

};

class NdbOperation {

  friend class Ndb;

  friend class NdbTransaction;

  friend class NdbScanOperation;

  friend class NdbScanReceiver;

  friend class NdbScanFilter;

  friend class NdbScanFilterImpl;

  friend class NdbReceiver;

  friend class NdbBlob;

public:

  enum Type {

    PrimaryKeyAccess = 0,

    UniqueIndexAccess = 1,

    TableScan = 2,

    OrderedIndexScan = 3, 

    };

  enum LockMode {

    LM_Read = 0,

    LM_Exclusive = 1,

    LM_CommittedRead = 2,

    LM_Dirty = 2

  };

#if defined(SWIGPYTHON)

  %rename(setValueU) setValue(const char *, Uint32);

  %rename(setValueU64) setValue(const char *, Uint64);

  %rename(setVal)  setValue(const char* anAttrName, const char* aValue);

  %rename(setVal)  setValue(const char* anAttrName, Int32 aValue);

  %rename(setVal)  setValue(const char* anAttrName, Uint32 aValue);

  %rename(setVal)  setValue(const char* anAttrName, Uint64 aValue);

  %rename(setVal)  setValue(const char* anAttrName, Int64 aValue);

  %rename(setVal)  setValue(const char* anAttrName, float aValue);

  %rename(setVal)  setValue(const char* anAttrName, double aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, const char* aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, Int32 aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, Uint32 aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, Int64 aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, Uint64 aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, float aValue);

  %rename(setVal)  setValue(Uint32 anAttrId, double aValue);

#endif

  int  setValue(const char* anAttrName, const char* aValue);

  int  setValue(const char* anAttrName, Int32 aValue);

  int  setValue(const char* anAttrName, Uint32 aValue);

  int  setValue(const char* anAttrName, Uint64 aValue);

  int  setValue(const char* anAttrName, Int64 aValue);

  int  setValue(const char* anAttrName, float aValue);

  int  setValue(const char* anAttrName, double aValue);

  int  setValue(Uint32 anAttrId, const char* aValue);

  int  setValue(Uint32 anAttrId, Int32 aValue);

  int  setValue(Uint32 anAttrId, Uint32 aValue);

  int  setValue(Uint32 anAttrId, Int64 aValue);

  int  setValue(Uint32 anAttrId, Uint64 aValue);

  int  setValue(Uint32 anAttrId, float aValue);

  int  setValue(Uint32 anAttrId, double aValue);

  const NdbError & getNdbError() const;

  virtual int insertTuple();

#if defined(SWIGPYTHON)

  %rename(equalU) equal(const char*, Uint32);

  %rename(equalU64) equal(const char*, Uint64);

  %rename(equalU) equal(Uint32, Uint32);

  %rename(equalU64) equal(Uint32, Uint64);

#endif

  int  equal(const char* anAttrName, const char* aValue);

  int  equal(const char* anAttrName, Uint32 aValue);	

  int  equal(const char* anAttrName, Int32 aValue);	

  int  equal(const char* anAttrName, Int64 aValue);	

  int  equal(const char* anAttrName, Uint64 aValue);

  int  equal(Uint32 anAttrId, const char* aValue);

  int  equal(Uint32 anAttrId, Int32 aValue);	

  int  equal(Uint32 anAttrId, Uint32 aValue);	

  int  equal(Uint32 anAttrId, Int64 aValue);	

  int  equal(Uint32 anAttrId, Uint64 aValue);

#if defined(SWIGPYTHON)

  %pythoncode %{

def setValue(self,name,value,length=None):

  if isinstance(value,"".__class__):

    value="%c%s" % (len(value),value)

  if length is None:

    return self.setVal(name,value)

  return self.setVal(name,value,length)

      %}

#endif

protected:

  NdbOperation(Ndb* aNdb, Type aType = PrimaryKeyAccess);	

  virtual ~NdbOperation();

};

class NdbError {

  enum Status {

    Success = ndberror_st_success,

    TemporaryError = ndberror_st_temporary,

    PermanentError = ndberror_st_permanent,

    UnknownResult = ndberror_st_unknown

  };

  enum Classification {

    NoError = ndberror_cl_none,

    ApplicationError = ndberror_cl_application,

    NoDataFound = ndberror_cl_no_data_found,

    ConstraintViolation = ndberror_cl_constraint_violation,

    SchemaError = ndberror_cl_schema_error,

    UserDefinedError = ndberror_cl_user_defined,

    InsufficientSpace = ndberror_cl_insufficient_space,

    TemporaryResourceError = ndberror_cl_temporary_resource,

    NodeRecoveryError = ndberror_cl_node_recovery,

    OverloadError = ndberror_cl_overload,

    TimeoutExpired = ndberror_cl_timeout_expired,

    UnknownResultError = ndberror_cl_unknown_result,

    InternalError = ndberror_cl_internal_error,

    FunctionNotImplemented = ndberror_cl_function_not_implemented,

    UnknownErrorCode = ndberror_cl_unknown_error_code,

    NodeShutdown = ndberror_cl_node_shutdown,

    SchemaObjectExists = ndberror_cl_schema_object_already_exists,

    InternalTemporary = ndberror_cl_internal_temporary

  };

  Status status;

  Classification classification;

  int code;

  int mysql_code;

  const char * message;

  char * details;

  NdbError(){

    status = UnknownResult;

    classification = NoError;

    code = 0;

    mysql_code = 0;

    message = 0;

    details = 0;

  }

  NdbError(const ndberror_struct & ndberror){

    status = (NdbError::Status) ndberror.status;

    classification = (NdbError::Classification) ndberror.classification;

    code = ndberror.code;

    mysql_code = ndberror.mysql_code;

    message = ndberror.message;

    details = ndberror.details;

  }

  operator ndberror_struct() const {

    ndberror_struct ndberror;

    ndberror.status = (ndberror_status_enum) status;

    ndberror.classification = (ndberror_classification_enum) classification;

    ndberror.code = code;

    ndberror.mysql_code = mysql_code;

    ndberror.message = message;

    ndberror.details = details;

    return ndberror;

  }

};

%extend NdbError { 

  const char * getMessage() { 

   return self->message; 

  }

}

/* test */

/* -*- mode: c++ -*- */