~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++ -*- */