Doc/lib/libcopyreg.tex


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

\section{\module{copy_reg} ---
         Register \module{pickle} support functions}

\declaremodule[copyreg]{standard}{copy_reg}
\modulesynopsis{Register \module{pickle} support functions.}


The \module{copy_reg} module provides support for the
\refmodule{pickle}\refstmodindex{pickle} and
\refmodule{cPickle}\refbimodindex{cPickle} modules.  The
\refmodule{copy}\refstmodindex{copy} module is likely to use this in the
future as well.  It provides configuration information about object
constructors which are not classes.  Such constructors may be factory
functions or class instances.


\begin{funcdesc}{constructor}{object}
  Declares \var{object} to be a valid constructor.  If \var{object} is
  not callable (and hence not valid as a constructor), raises
  \exception{TypeError}.
\end{funcdesc}

\begin{funcdesc}{pickle}{type, function\optional{, constructor}}
  Declares that \var{function} should be used as a ``reduction''
  function for objects of type \var{type}; \var{type} should not a
  class object.  \var{function} should return either a string or a
  tuple.  The optional \var{constructor} parameter, if provided, is a
  callable object which can be used to reconstruct the object when
  called with the tuple of arguments returned by \var{function} at
  pickling time.  \exception{TypeError} will be raised if
  \var{object} is a class or \var{constructor} is not callable.
\end{funcdesc}
/*
Subject: Re: Sybase module -- input sought 
From: jredford@lehman.com
To: ags@uncompaghre.informatics.jax.org (Alexander G. Smith)
Cc: python-list@cwi.nl
Date: Tue, 10 May 94 11:53:13 -0400


input sought? how about a complete module? :)

This is a fairly incomplete work.. but I have done things dramatically
differently than sybperl would. Given the nature of the language I
find it is easier to simply get ALL results & then muck with the rows
later as parts of the data. This is a subset of the functionality of a
Modula-3 interface to Sybase that I wrote.. I could send you that if
you are interested in a more complete picture.
*/

#include <stdio.h>

#include <sybfront.h>
#include <sybdb.h>

#include "allobjects.h"
#include "modsupport.h"


static object *SybaseError;	/* exception sybase.error */


typedef struct {
        OB_HEAD
	LOGINREC *login;	/* login record */
	DBPROCESS *dbproc;	/* login record */
} sybdbobject;

extern typeobject SybDbtype; /* Forward */


static sybdbobject *
  newsybdbobject(char *user, char *passwd, char *server)
{
  sybdbobject *s;

  s = NEWOBJ(sybdbobject, &SybDbtype);
  if (s != NULL) {
    s->login = dblogin();
    if (user) {
      (void)DBSETLUSER(s->login, user);
    }
    if (passwd) {
      (void)DBSETLPWD(s->login, passwd);
    }
    if(!(s->dbproc = dbopen(s->login, server))) {
      dbloginfree(s->login);
      DEL(s);
      return (NULL);
    }
  }
  return s;
}

/* OBJECT FUNCTIONS: sybdb */

/* Common code for returning pending results */
static object
  *getresults (DBPROCESS *dbp)
{
  object *results;
  object *list;
  object *tuple;
  object *o;
  int retcode;
  int cols;
  int *fmt;
  int i;

  results = newlistobject(0);
  while ((retcode = dbresults(dbp)) != NO_MORE_RESULTS) {
    if (retcode == SUCCEED && DBROWS(dbp) == SUCCEED) {
      list = newlistobject(0);
      cols = dbnumcols(dbp);
      fmt = (int *)malloc(sizeof(int) * cols);
      for (i = 1; i <= cols; i++) {
	switch(dbcoltype(dbp, i)) {
	case SYBCHAR:
	  fmt[i-1] = SYBCHAR;
	  break;
	case SYBINT1:
	  fmt[i-1] = SYBINT1;
	  break;
	case SYBINT2:
	  fmt[i-1] = SYBINT2;
	  break;
	case SYBINT4:
	  fmt[i-1] = SYBINT4;
	  break;
	case SYBFLT8:
	  fmt[i-1] = SYBFLT8;
	  break;
	}
      }
      while (dbnextrow(dbp) != NO_MORE_ROWS) {
	tuple = newtupleobject(cols);
	for (i = 1; i <= cols; i++) {
	  switch(fmt[i-1]) {
	  case SYBCHAR:
	    o = newsizedstringobject((char *)dbdata(dbp, i), dbdatlen(dbp, i));
	    settupleitem(tuple, i-1, o);
	    break;
	  case SYBINT1:
	    o = newintobject(*((char *)dbdata(dbp, i)));
	    settupleitem(tuple, i-1, o);
	    break;
	  case SYBINT2:
	    o = newintobject(*((short *)dbdata(dbp, i)));
	    settupleitem(tuple, i-1, o);
	    break;
	  case SYBINT4:
	    o = newintobject(*((int *)dbdata(dbp, i)));
	    settupleitem(tuple, i-1, o);
	    break;
	  case SYBFLT8:
	    o = newfloatobject(*((double *)dbdata(dbp, i)));
	    settupleitem(tuple, i-1, o);
	    break;
	  }
	}
	addlistitem(list,tuple);
      }
      free(fmt);
      addlistitem(results,list);
    }
  }
  return (results);
}

static object
  *sybdb_sql (self, args)
object *self;
object *args;
{
  char *sql;
  DBPROCESS *dbp;

  dbp = ((sybdbobject *)self)->dbproc;
  err_clear ();
  if (!getargs (args, "s", &sql)) {
    return NULL;
  }
  dbcancel(dbp);
  dbcmd(dbp, sql);
  dbsqlexec(dbp);
  return getresults(dbp);
}

static object
  *sybdb_sp (self, args)
object *self;
object *args;
{
  char *sp;
  DBPROCESS *dbp;
  object *spargs;
  object *sparg;
  object *results;
  object *r;
  int spargcnt;
  int i;
  int retstatus;

  dbp = ((sybdbobject *)self)->dbproc;
  err_clear ();
  if (!getargs (args, "(sO)", &sp, &spargs)) {
    return NULL;
  }

  dbcancel(dbp);
  dbrpcinit(dbp, sp, 0);

  if (is_tupleobject(spargs)) {
    spargcnt=gettuplesize(spargs);
    for (i=0; i < spargcnt; i++) {
      sparg = gettupleitem(spargs,i);
      if (is_intobject(sparg)) {
	int i;
	i = getintvalue(sparg);
	dbrpcparam(dbp, NULL, 0, SYBINT4, -1, -1, &i);
      } else if (is_floatobject(sparg)) {
	double i;
	i = getfloatvalue(sparg);
	dbrpcparam(dbp, NULL, 0, SYBFLT8, -1, -1, &i);
      } else if (is_stringobject(sparg)) {
	dbrpcparam(dbp, NULL, 0, SYBCHAR, -1, getstringsize(sparg), getstringvalue(sparg));
      } else {
	err_setstr (SybaseError, "Could not handle paramaters to procedure.");
	return NULL;
      }
    }
  } else if (spargs != None) {
    err_setstr (SybaseError, "Could not handle paramaters to procedure.");
    return NULL;
  }
  dbrpcsend(dbp);
  dbsqlok(dbp);

  results = getresults(dbp);
  retstatus = dbretstatus(dbp);

  r = mkvalue("(iO)", retstatus, results);
  DECREF(results);
  return (r);
}


static struct methodlist sybdb_methods[] = {
  {"sql",        sybdb_sql},
  {"sp",         sybdb_sp},
  {NULL,         NULL}		/* sentinel */
};

static void
sybdb_dealloc(s)
     sybdbobject *s;
{
  dbloginfree(s->login);
  dbclose(s->dbproc);
  DEL(s);
}

static object *
sybdb_getattr(s, name)
     sybdbobject *s;
     char *name;
{
  return findmethod(sybdb_methods, (object *) s, name);
}


typeobject SybDbtype = {
        OB_HEAD_INIT(&Typetype)
        0,
        "sybdb",
        sizeof(sybdbobject),
        0,
        sybdb_dealloc,		/*tp_dealloc*/
        0,			/*tp_print*/
        sybdb_getattr,		/*tp_getattr*/
        0,			/*tp_setattr*/
        0,			/*tp_compare*/
        0,			/*tp_repr*/
        0,			/*tp_as_number*/
        0,			/*tp_as_sequence*/
        0,			/*tp_as_mapping*/
};


/* MODULE FUNCTIONS: sybase */

static object
  *sybase_new (self, args)
object *self;		/* Not used */
object *args;
{
  char *user, *passwd, *server;
  object *db;

  err_clear ();
  if (!getargs (args, "(zzz)", &user, &passwd, &server)) {
    return NULL;
  }
  db = (object *) newsybdbobject(user, passwd, server);
  if (!db) {
    /* XXX Should be setting some errstr stuff here based on sybase errors */
    err_setstr (SybaseError, "Could not open connection to server.");
    return NULL;
  }
  return db;
}


/* List of module functions */
static struct methodlist sybase_methods[]=
{
  {"new", sybase_new},
  {NULL, NULL}			/* sentinel */
};

/* Module initialisation */
void initsybase ()
{
  object *m, *d;

  /* Create the module and add the functions */
  m = initmodule ("sybase", sybase_methods);
  /* Add some symbolic constants to the module */
  d = getmoduledict (m);
  SybaseError = newstringobject ("sybase.error");
  if (SybaseError == NULL || dictinsert (d, "error", SybaseError) != 0) {
    fatal ("can't define sybase.error");
  }
  /* Check for errors */
  if (err_occurred ()){
    fatal ("can't initialize module sybase");
  }
}