| rev | 
   line source | 
| 
jbe/bsw@0
 | 
     1 #include <lua.h>
 | 
| 
jbe/bsw@0
 | 
     2 #include <lauxlib.h>
 | 
| 
jbe/bsw@0
 | 
     3 #include <libpq-fe.h>
 | 
| 
jbe/bsw@0
 | 
     4 #include <postgres.h>
 | 
| 
jbe/bsw@0
 | 
     5 #include <catalog/pg_type.h>
 | 
| 
jbe/bsw@0
 | 
     6 #include <stdint.h>
 | 
| 
jbe/bsw@0
 | 
     7 
 | 
| 
jbe@23
 | 
     8 // NOTE: Comments with format "// <number>" denote the Lua stack position
 | 
| 
jbe@23
 | 
     9 
 | 
| 
jbe@23
 | 
    10 // prefix for all Lua registry entries of this library:
 | 
| 
jbe@23
 | 
    11 #define MONDELEFANT_REGKEY "e449ba8d9a53d353_mondelefant_"
 | 
| 
jbe/bsw@0
 | 
    12 
 | 
| 
jbe@23
 | 
    13 // registry key of module "mondelefant_native":
 | 
| 
jbe@23
 | 
    14 #define MONDELEFANT_MODULE_REGKEY (MONDELEFANT_REGKEY "module")
 | 
| 
jbe@23
 | 
    15 // registry key of meta-table for database connections:
 | 
| 
jbe@23
 | 
    16 #define MONDELEFANT_CONN_MT_REGKEY (MONDELEFANT_REGKEY "connection")
 | 
| 
jbe@23
 | 
    17 // registry key of table storing connection specific data:
 | 
| 
jbe@23
 | 
    18 #define MONDELEFANT_CONN_DATA_REGKEY (MONDELEFANT_REGKEY "connection_data")
 | 
| 
jbe@23
 | 
    19 // registry key of meta-table for database result lists and objects:
 | 
| 
jbe@23
 | 
    20 #define MONDELEFANT_RESULT_MT_REGKEY (MONDELEFANT_REGKEY "result")
 | 
| 
jbe@23
 | 
    21 // registry key of meta-table for database error objects:
 | 
| 
jbe@23
 | 
    22 #define MONDELEFANT_ERROROBJECT_MT_REGKEY (MONDELEFANT_REGKEY "errorobject")
 | 
| 
jbe@23
 | 
    23 // registry key of meta-table for models (named classes here):
 | 
| 
jbe@23
 | 
    24 #define MONDELEFANT_CLASS_MT_REGKEY (MONDELEFANT_REGKEY "class")
 | 
| 
jbe@23
 | 
    25 // registry key of default prototype for models/classes:
 | 
| 
jbe@23
 | 
    26 #define MONDELEFANT_CLASS_PROTO_REGKEY (MONDELEFANT_REGKEY "class_proto")
 | 
| 
jbe/bsw@0
 | 
    27 
 | 
| 
jbe@23
 | 
    28 // C-structure for database connection userdata:
 | 
| 
jbe/bsw@0
 | 
    29 typedef struct {
 | 
| 
jbe/bsw@0
 | 
    30   PGconn *pgconn;
 | 
| 
jbe/bsw@0
 | 
    31   int server_encoding;
 | 
| 
jbe/bsw@0
 | 
    32 } mondelefant_conn_t;
 | 
| 
jbe@23
 | 
    33 #define MONDELEFANT_SERVER_ENCODING_ASCII 0
 | 
| 
jbe@23
 | 
    34 #define MONDELEFANT_SERVER_ENCODING_UTF8  1
 | 
| 
jbe/bsw@0
 | 
    35 
 | 
| 
jbe@23
 | 
    36 // transform codepoint-position to byte-position for a given UTF-8 string:
 | 
| 
jbe/bsw@0
 | 
    37 static size_t utf8_position_to_byte(const char *str, size_t utf8pos) {
 | 
| 
jbe/bsw@0
 | 
    38   size_t bytepos;
 | 
| 
jbe/bsw@0
 | 
    39   for (bytepos = 0; utf8pos > 0; bytepos++) {
 | 
| 
jbe/bsw@0
 | 
    40     uint8_t c;
 | 
| 
jbe/bsw@0
 | 
    41     c = ((const uint8_t *)str)[bytepos];
 | 
| 
jbe/bsw@0
 | 
    42     if (!c) break;
 | 
| 
jbe/bsw@0
 | 
    43     if (c <= 0x7f || c >= 0xc0) utf8pos--;
 | 
| 
jbe/bsw@0
 | 
    44   }
 | 
| 
jbe/bsw@0
 | 
    45   return bytepos;
 | 
| 
jbe/bsw@0
 | 
    46 }
 | 
| 
jbe/bsw@0
 | 
    47 
 | 
| 
jbe@23
 | 
    48 // PostgreSQL's OID for binary data type (bytea):
 | 
| 
jbe/bsw@0
 | 
    49 #define MONDELEFANT_POSTGRESQL_BINARY_OID ((Oid)17)
 | 
| 
jbe/bsw@0
 | 
    50 
 | 
| 
jbe@23
 | 
    51 // mapping a PostgreSQL type given by its OID to a string identifier:
 | 
| 
jbe/bsw@0
 | 
    52 static const char *mondelefant_oid_to_typestr(Oid oid) {
 | 
| 
jbe/bsw@0
 | 
    53   switch (oid) {
 | 
| 
jbe/bsw@0
 | 
    54     case 16: return "bool";
 | 
| 
jbe/bsw@0
 | 
    55     case 17: return "bytea";
 | 
| 
jbe/bsw@0
 | 
    56     case 18: return "char";
 | 
| 
jbe/bsw@0
 | 
    57     case 19: return "name";
 | 
| 
jbe/bsw@0
 | 
    58     case 20: return "int8";
 | 
| 
jbe/bsw@0
 | 
    59     case 21: return "int2";
 | 
| 
jbe/bsw@0
 | 
    60     case 23: return "int4";
 | 
| 
jbe/bsw@0
 | 
    61     case 25: return "text";
 | 
| 
jbe/bsw@0
 | 
    62     case 26: return "oid";
 | 
| 
jbe/bsw@0
 | 
    63     case 27: return "tid";
 | 
| 
jbe/bsw@0
 | 
    64     case 28: return "xid";
 | 
| 
jbe/bsw@0
 | 
    65     case 29: return "cid";
 | 
| 
jbe@176
 | 
    66     case 114: return "json";
 | 
| 
jbe/bsw@0
 | 
    67     case 600: return "point";
 | 
| 
jbe/bsw@0
 | 
    68     case 601: return "lseg";
 | 
| 
jbe/bsw@0
 | 
    69     case 602: return "path";
 | 
| 
jbe/bsw@0
 | 
    70     case 603: return "box";
 | 
| 
jbe/bsw@0
 | 
    71     case 604: return "polygon";
 | 
| 
jbe/bsw@0
 | 
    72     case 628: return "line";
 | 
| 
jbe/bsw@0
 | 
    73     case 700: return "float4";
 | 
| 
jbe/bsw@0
 | 
    74     case 701: return "float8";
 | 
| 
jbe/bsw@0
 | 
    75     case 705: return "unknown";
 | 
| 
jbe/bsw@0
 | 
    76     case 718: return "circle";
 | 
| 
jbe/bsw@0
 | 
    77     case 790: return "money";
 | 
| 
jbe/bsw@0
 | 
    78     case 829: return "macaddr";
 | 
| 
jbe/bsw@0
 | 
    79     case 869: return "inet";
 | 
| 
jbe/bsw@0
 | 
    80     case 650: return "cidr";
 | 
| 
jbe/bsw@0
 | 
    81     case 1042: return "bpchar";
 | 
| 
jbe/bsw@0
 | 
    82     case 1043: return "varchar";
 | 
| 
jbe/bsw@0
 | 
    83     case 1082: return "date";
 | 
| 
jbe/bsw@0
 | 
    84     case 1083: return "time";
 | 
| 
jbe/bsw@0
 | 
    85     case 1114: return "timestamp";
 | 
| 
jbe/bsw@0
 | 
    86     case 1184: return "timestamptz";
 | 
| 
jbe/bsw@0
 | 
    87     case 1186: return "interval";
 | 
| 
jbe/bsw@0
 | 
    88     case 1266: return "timetz";
 | 
| 
jbe/bsw@0
 | 
    89     case 1560: return "bit";
 | 
| 
jbe/bsw@0
 | 
    90     case 1562: return "varbit";
 | 
| 
jbe/bsw@0
 | 
    91     case 1700: return "numeric";
 | 
| 
jbe@176
 | 
    92     case 3802: return "jsonb";
 | 
| 
jbe/bsw@0
 | 
    93     default: return NULL;
 | 
| 
jbe/bsw@0
 | 
    94   }
 | 
| 
jbe/bsw@0
 | 
    95 }
 | 
| 
jbe/bsw@0
 | 
    96 
 | 
| 
jbe@23
 | 
    97 // This library maps PostgreSQL's error codes to CamelCase string
 | 
| 
jbe@23
 | 
    98 // identifiers, which consist of CamelCase identifiers and are seperated
 | 
| 
jbe@23
 | 
    99 // by dots (".") (no leading or trailing dots).
 | 
| 
jbe@23
 | 
   100 // There are additional error identifiers which do not have a corresponding
 | 
| 
jbe@23
 | 
   101 // PostgreSQL error associated with it.
 | 
| 
jbe@23
 | 
   102 
 | 
| 
jbe@23
 | 
   103 // matching start of local variable 'pgcode' against string 'incode',
 | 
| 
jbe@23
 | 
   104 // returning string 'outcode' on match:
 | 
| 
jbe/bsw@0
 | 
   105 #define mondelefant_errcode_item(incode, outcode) \
 | 
| 
jbe/bsw@0
 | 
   106   if (!strncmp(pgcode, (incode), strlen(incode))) return outcode; else
 | 
| 
jbe/bsw@0
 | 
   107 
 | 
| 
jbe@23
 | 
   108 // additional error identifiers without corresponding PostgreSQL error:
 | 
| 
jbe/bsw@0
 | 
   109 #define MONDELEFANT_ERRCODE_UNKNOWN "unknown"
 | 
| 
jbe/bsw@0
 | 
   110 #define MONDELEFANT_ERRCODE_CONNECTION "ConnectionException"
 | 
| 
jbe/bsw@0
 | 
   111 #define MONDELEFANT_ERRCODE_RESULTCOUNT_LOW "WrongResultSetCount.ResultSetMissing"
 | 
| 
jbe/bsw@0
 | 
   112 #define MONDELEFANT_ERRCODE_RESULTCOUNT_HIGH "WrongResultSetCount.TooManyResults"
 | 
| 
jbe/bsw@0
 | 
   113 #define MONDELEFANT_ERRCODE_QUERY1_NO_ROWS "NoData.OneRowExpected"
 | 
| 
jbe/bsw@0
 | 
   114 #define MONDELEFANT_ERRCODE_QUERY1_MULTIPLE_ROWS "CardinalityViolation.OneRowExpected"
 | 
| 
jbe/bsw@0
 | 
   115 
 | 
| 
jbe@23
 | 
   116 // mapping PostgreSQL error code to error code as returned by this library:
 | 
| 
jbe/bsw@0
 | 
   117 static const char *mondelefant_translate_errcode(const char *pgcode) {
 | 
| 
jbe/bsw@0
 | 
   118   if (!pgcode) abort();  // should not happen
 | 
| 
jbe/bsw@0
 | 
   119   mondelefant_errcode_item("02", "NoData")
 | 
| 
jbe/bsw@0
 | 
   120   mondelefant_errcode_item("03", "SqlStatementNotYetComplete")
 | 
| 
jbe/bsw@0
 | 
   121   mondelefant_errcode_item("08", "ConnectionException")
 | 
| 
jbe/bsw@0
 | 
   122   mondelefant_errcode_item("09", "TriggeredActionException")
 | 
| 
jbe/bsw@0
 | 
   123   mondelefant_errcode_item("0A", "FeatureNotSupported")
 | 
| 
jbe/bsw@0
 | 
   124   mondelefant_errcode_item("0B", "InvalidTransactionInitiation")
 | 
| 
jbe/bsw@0
 | 
   125   mondelefant_errcode_item("0F", "LocatorException")
 | 
| 
jbe/bsw@0
 | 
   126   mondelefant_errcode_item("0L", "InvalidGrantor")
 | 
| 
jbe/bsw@0
 | 
   127   mondelefant_errcode_item("0P", "InvalidRoleSpecification")
 | 
| 
jbe/bsw@0
 | 
   128   mondelefant_errcode_item("21", "CardinalityViolation")
 | 
| 
jbe/bsw@0
 | 
   129   mondelefant_errcode_item("22", "DataException")
 | 
| 
jbe/bsw@0
 | 
   130   mondelefant_errcode_item("23001", "IntegrityConstraintViolation.RestrictViolation")
 | 
| 
jbe/bsw@0
 | 
   131   mondelefant_errcode_item("23502", "IntegrityConstraintViolation.NotNullViolation")
 | 
| 
jbe/bsw@0
 | 
   132   mondelefant_errcode_item("23503", "IntegrityConstraintViolation.ForeignKeyViolation")
 | 
| 
jbe/bsw@0
 | 
   133   mondelefant_errcode_item("23505", "IntegrityConstraintViolation.UniqueViolation")
 | 
| 
jbe/bsw@0
 | 
   134   mondelefant_errcode_item("23514", "IntegrityConstraintViolation.CheckViolation")
 | 
| 
jbe/bsw@0
 | 
   135   mondelefant_errcode_item("23",    "IntegrityConstraintViolation")
 | 
| 
jbe/bsw@0
 | 
   136   mondelefant_errcode_item("24", "InvalidCursorState")
 | 
| 
jbe/bsw@0
 | 
   137   mondelefant_errcode_item("25", "InvalidTransactionState")
 | 
| 
jbe/bsw@0
 | 
   138   mondelefant_errcode_item("26", "InvalidSqlStatementName")
 | 
| 
jbe/bsw@0
 | 
   139   mondelefant_errcode_item("27", "TriggeredDataChangeViolation")
 | 
| 
jbe/bsw@0
 | 
   140   mondelefant_errcode_item("28", "InvalidAuthorizationSpecification")
 | 
| 
jbe/bsw@0
 | 
   141   mondelefant_errcode_item("2B", "DependentPrivilegeDescriptorsStillExist")
 | 
| 
jbe/bsw@0
 | 
   142   mondelefant_errcode_item("2D", "InvalidTransactionTermination")
 | 
| 
jbe/bsw@0
 | 
   143   mondelefant_errcode_item("2F", "SqlRoutineException")
 | 
| 
jbe/bsw@0
 | 
   144   mondelefant_errcode_item("34", "InvalidCursorName")
 | 
| 
jbe/bsw@0
 | 
   145   mondelefant_errcode_item("38", "ExternalRoutineException")
 | 
| 
jbe/bsw@0
 | 
   146   mondelefant_errcode_item("39", "ExternalRoutineInvocationException")
 | 
| 
jbe/bsw@0
 | 
   147   mondelefant_errcode_item("3B", "SavepointException")
 | 
| 
jbe/bsw@0
 | 
   148   mondelefant_errcode_item("3D", "InvalidCatalogName")
 | 
| 
jbe/bsw@0
 | 
   149   mondelefant_errcode_item("3F", "InvalidSchemaName")
 | 
| 
jbe/bsw@0
 | 
   150   mondelefant_errcode_item("40", "TransactionRollback")
 | 
| 
jbe/bsw@0
 | 
   151   mondelefant_errcode_item("42", "SyntaxErrorOrAccessRuleViolation")
 | 
| 
jbe/bsw@0
 | 
   152   mondelefant_errcode_item("44", "WithCheckOptionViolation")
 | 
| 
jbe/bsw@0
 | 
   153   mondelefant_errcode_item("53", "InsufficientResources")
 | 
| 
jbe/bsw@0
 | 
   154   mondelefant_errcode_item("54", "ProgramLimitExceeded")
 | 
| 
jbe/bsw@0
 | 
   155   mondelefant_errcode_item("55", "ObjectNotInPrerequisiteState")
 | 
| 
jbe/bsw@0
 | 
   156   mondelefant_errcode_item("57", "OperatorIntervention")
 | 
| 
jbe/bsw@0
 | 
   157   mondelefant_errcode_item("58", "SystemError")
 | 
| 
jbe/bsw@0
 | 
   158   mondelefant_errcode_item("F0", "ConfigurationFileError")
 | 
| 
jbe/bsw@0
 | 
   159   mondelefant_errcode_item("P0", "PlpgsqlError")
 | 
| 
jbe/bsw@0
 | 
   160   mondelefant_errcode_item("XX", "InternalError")
 | 
| 
jbe/bsw@0
 | 
   161   return "unknown";
 | 
| 
jbe/bsw@0
 | 
   162 }
 | 
| 
jbe/bsw@0
 | 
   163 
 | 
| 
jbe@23
 | 
   164 // C-function, checking if a given error code (as defined by this library)
 | 
| 
jbe@23
 | 
   165 // is belonging to a certain class of errors (strings are equal or error
 | 
| 
jbe@23
 | 
   166 // code begins with error class followed by a dot):
 | 
| 
jbe/bsw@0
 | 
   167 static int mondelefant_check_error_class(
 | 
| 
jbe/bsw@0
 | 
   168   const char *errcode, const char *errclass
 | 
| 
jbe/bsw@0
 | 
   169 ) {
 | 
| 
jbe/bsw@0
 | 
   170   size_t i = 0;
 | 
| 
jbe/bsw@0
 | 
   171   while (1) {
 | 
| 
jbe/bsw@0
 | 
   172     if (errclass[i] == 0) {
 | 
| 
jbe/bsw@0
 | 
   173       if (errcode[i] == 0 || errcode[i] == '.') return 1;
 | 
| 
jbe/bsw@0
 | 
   174       else return 0;
 | 
| 
jbe/bsw@0
 | 
   175     }
 | 
| 
jbe/bsw@0
 | 
   176     if (errcode[i] != errclass[i]) return 0;
 | 
| 
jbe/bsw@0
 | 
   177     i++;
 | 
| 
jbe/bsw@0
 | 
   178   }
 | 
| 
jbe/bsw@0
 | 
   179 }
 | 
| 
jbe/bsw@0
 | 
   180 
 | 
| 
jbe@23
 | 
   181 // pushing first line of a string on Lua's stack (without trailing CR/LF):
 | 
| 
jbe/bsw@0
 | 
   182 static void mondelefant_push_first_line(lua_State *L, const char *str) {
 | 
| 
jbe/bsw@0
 | 
   183   char *str2;
 | 
| 
jbe/bsw@0
 | 
   184   size_t i = 0;
 | 
| 
jbe/bsw@0
 | 
   185   if (!str) abort();  // should not happen
 | 
| 
jbe/bsw@0
 | 
   186   str2 = strdup(str);
 | 
| 
jbe/bsw@0
 | 
   187   while (1) {
 | 
| 
jbe/bsw@0
 | 
   188     char c = str2[i];
 | 
| 
jbe/bsw@0
 | 
   189     if (c == '\n' || c == '\r' || c == 0) { str2[i] = 0; break; }
 | 
| 
jbe/bsw@0
 | 
   190     i++;
 | 
| 
jbe/bsw@0
 | 
   191   };
 | 
| 
jbe/bsw@0
 | 
   192   lua_pushstring(L, str2);
 | 
| 
jbe/bsw@0
 | 
   193   free(str2);
 | 
| 
jbe/bsw@0
 | 
   194 }
 | 
| 
jbe/bsw@0
 | 
   195 
 | 
| 
jbe@23
 | 
   196 // "connect" function of library, which establishes a database connection
 | 
| 
jbe@23
 | 
   197 // and returns a database connection handle:
 | 
| 
jbe/bsw@0
 | 
   198 static int mondelefant_connect(lua_State *L) {
 | 
| 
jbe@23
 | 
   199   luaL_Buffer buf;  // Lua string buffer to create 'conninfo' (see below)
 | 
| 
jbe@23
 | 
   200   const char *conninfo;  // string for PQconnectdb function
 | 
| 
jbe@23
 | 
   201   PGconn *pgconn;  // PGconn object as returned by PQconnectdb function
 | 
| 
jbe@23
 | 
   202   mondelefant_conn_t *conn;  // C-structure for userdata
 | 
| 
jbe@23
 | 
   203   // if engine is anything but "postgresql", then raise error:
 | 
| 
jbe/bsw@0
 | 
   204   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
   205   lua_getfield(L, 1, "engine");  // 2
 | 
| 
jbe/bsw@0
 | 
   206   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
   207     return luaL_error(L, "No database engine selected.");
 | 
| 
jbe/bsw@0
 | 
   208   }
 | 
| 
jbe/bsw@0
 | 
   209   lua_pushliteral(L, "postgresql");  // 3
 | 
| 
jbe/bsw@0
 | 
   210   if (!lua_rawequal(L, 2, 3)) {
 | 
| 
jbe/bsw@0
 | 
   211     return luaL_error(L,
 | 
| 
jbe/bsw@0
 | 
   212       "Only database engine 'postgresql' is supported."
 | 
| 
jbe/bsw@0
 | 
   213     );
 | 
| 
jbe/bsw@0
 | 
   214   }
 | 
| 
jbe@40
 | 
   215   // copy conninfo string for PQconnectdb function from argument table to
 | 
| 
jbe@40
 | 
   216   // stack position 2:
 | 
| 
jbe/bsw@0
 | 
   217   lua_settop(L, 1);
 | 
| 
jbe@40
 | 
   218   lua_getfield(L, 1, "conninfo");  // 2
 | 
| 
jbe@40
 | 
   219   // if no conninfo string was found, then assemble one from the named
 | 
| 
jbe@40
 | 
   220   // options except "engine" option:
 | 
| 
jbe@40
 | 
   221   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe@40
 | 
   222     lua_settop(L, 1);
 | 
| 
jbe@40
 | 
   223     lua_pushnil(L);  // slot for key at stack position 2
 | 
| 
jbe@40
 | 
   224     lua_pushnil(L);  // slot for value at stack position 3
 | 
| 
jbe@40
 | 
   225     luaL_buffinit(L, &buf);
 | 
| 
jbe@40
 | 
   226     {
 | 
| 
jbe@40
 | 
   227       int need_seperator = 0;
 | 
| 
jbe@40
 | 
   228       while (lua_pushvalue(L, 2), lua_next(L, 1)) {
 | 
| 
jbe@40
 | 
   229         lua_replace(L, 3);
 | 
| 
jbe@40
 | 
   230         lua_replace(L, 2);
 | 
| 
jbe@40
 | 
   231         // NOTE: numbers will be converted to strings automatically here,
 | 
| 
jbe@40
 | 
   232         // but perhaps this will change in future versions of lua
 | 
| 
jbe@40
 | 
   233         luaL_argcheck(L,
 | 
| 
jbe@40
 | 
   234           lua_isstring(L, 2) && lua_isstring(L, 3), 1, "non-string contained"
 | 
| 
jbe@40
 | 
   235         );
 | 
| 
jbe@40
 | 
   236         lua_pushvalue(L, 2);
 | 
| 
jbe@40
 | 
   237         lua_pushliteral(L, "engine");
 | 
| 
jbe@40
 | 
   238         if (!lua_rawequal(L, -2, -1)) {
 | 
| 
jbe@40
 | 
   239           const char *value;
 | 
| 
jbe@40
 | 
   240           size_t value_len;
 | 
| 
jbe@40
 | 
   241           size_t value_pos = 0;
 | 
| 
jbe@40
 | 
   242           lua_pop(L, 1);
 | 
| 
jbe@40
 | 
   243           if (need_seperator) luaL_addchar(&buf, ' ');
 | 
| 
jbe@40
 | 
   244           luaL_addvalue(&buf);
 | 
| 
jbe@40
 | 
   245           luaL_addchar(&buf, '=');
 | 
| 
jbe@40
 | 
   246           luaL_addchar(&buf, '\'');
 | 
| 
jbe@40
 | 
   247           value = lua_tolstring(L, 3, &value_len);
 | 
| 
jbe@40
 | 
   248           do {
 | 
| 
jbe@40
 | 
   249             char c;
 | 
| 
jbe@40
 | 
   250             c = value[value_pos++];
 | 
| 
jbe@40
 | 
   251             if (c == '\'') luaL_addchar(&buf, '\\');
 | 
| 
jbe@40
 | 
   252             luaL_addchar(&buf, c);
 | 
| 
jbe@40
 | 
   253           } while (value_pos < value_len);
 | 
| 
jbe@40
 | 
   254           luaL_addchar(&buf, '\'');
 | 
| 
jbe@40
 | 
   255           need_seperator = 1;
 | 
| 
jbe@40
 | 
   256         } else {
 | 
| 
jbe@40
 | 
   257           lua_pop(L, 1);
 | 
| 
jbe@40
 | 
   258         }
 | 
| 
jbe/bsw@0
 | 
   259       }
 | 
| 
jbe/bsw@0
 | 
   260     }
 | 
| 
jbe@40
 | 
   261     luaL_pushresult(&buf);
 | 
| 
jbe@40
 | 
   262     lua_replace(L, 2);
 | 
| 
jbe@40
 | 
   263     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   264   }
 | 
| 
jbe@40
 | 
   265   // use conninfo string on stack position 2:
 | 
| 
jbe/bsw@0
 | 
   266   conninfo = lua_tostring(L, 2);
 | 
| 
jbe@23
 | 
   267   // call PQconnectdb function of libpq:
 | 
| 
jbe/bsw@0
 | 
   268   pgconn = PQconnectdb(conninfo);
 | 
| 
jbe@23
 | 
   269   // throw errors, if neccessary:
 | 
| 
jbe/bsw@0
 | 
   270   if (!pgconn) {
 | 
| 
jbe/bsw@0
 | 
   271     return luaL_error(L,
 | 
| 
jbe/bsw@0
 | 
   272       "Error in libpq while creating 'PGconn' structure."
 | 
| 
jbe/bsw@0
 | 
   273     );
 | 
| 
jbe/bsw@0
 | 
   274   }
 | 
| 
jbe/bsw@0
 | 
   275   if (PQstatus(pgconn) != CONNECTION_OK) {
 | 
| 
jbe/bsw@0
 | 
   276     const char *errmsg;
 | 
| 
jbe/bsw@0
 | 
   277     lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
   278     errmsg = PQerrorMessage(pgconn);
 | 
| 
jbe/bsw@0
 | 
   279     if (errmsg) {
 | 
| 
jbe/bsw@0
 | 
   280       mondelefant_push_first_line(L, errmsg);
 | 
| 
jbe/bsw@0
 | 
   281     } else {
 | 
| 
jbe/bsw@0
 | 
   282       lua_pushliteral(L,
 | 
| 
jbe/bsw@0
 | 
   283         "Error while connecting to database, but no error message given."
 | 
| 
jbe/bsw@0
 | 
   284       );
 | 
| 
jbe/bsw@0
 | 
   285     }
 | 
| 
jbe/bsw@0
 | 
   286     lua_pushliteral(L, MONDELEFANT_ERRCODE_CONNECTION);
 | 
| 
jbe/bsw@0
 | 
   287     PQfinish(pgconn);
 | 
| 
jbe/bsw@0
 | 
   288     return 3;
 | 
| 
jbe/bsw@0
 | 
   289   }
 | 
| 
jbe@23
 | 
   290   // create userdata:
 | 
| 
jbe/bsw@0
 | 
   291   lua_settop(L, 0);
 | 
| 
jbe/bsw@0
 | 
   292   conn = lua_newuserdata(L, sizeof(*conn));  // 1
 | 
| 
jbe@23
 | 
   293   // set 'pgconn' in C-struct of userdata:
 | 
| 
jbe/bsw@0
 | 
   294   conn->pgconn = pgconn;
 | 
| 
jbe@23
 | 
   295   // set 'server_encoding' in C-struct of userdata:
 | 
| 
jbe/bsw@0
 | 
   296   {
 | 
| 
jbe/bsw@0
 | 
   297     const char *charset;
 | 
| 
jbe/bsw@0
 | 
   298     charset = PQparameterStatus(pgconn, "server_encoding");
 | 
| 
jbe/bsw@0
 | 
   299     if (charset && !strcmp(charset, "UTF8")) {
 | 
| 
jbe/bsw@0
 | 
   300       conn->server_encoding = MONDELEFANT_SERVER_ENCODING_UTF8;
 | 
| 
jbe/bsw@0
 | 
   301     } else {
 | 
| 
jbe/bsw@0
 | 
   302       conn->server_encoding = MONDELEFANT_SERVER_ENCODING_ASCII;
 | 
| 
jbe/bsw@0
 | 
   303     }
 | 
| 
jbe/bsw@0
 | 
   304   }
 | 
| 
jbe@23
 | 
   305   // set meta-table of userdata:
 | 
| 
jbe/bsw@0
 | 
   306   luaL_getmetatable(L, MONDELEFANT_CONN_MT_REGKEY);  // 2
 | 
| 
jbe/bsw@0
 | 
   307   lua_setmetatable(L, 1);
 | 
| 
jbe@23
 | 
   308   // create entry in table storing connection specific data and associate
 | 
| 
jbe@23
 | 
   309   // created userdata with it:
 | 
| 
jbe/bsw@0
 | 
   310   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CONN_DATA_REGKEY);  // 2
 | 
| 
jbe/bsw@0
 | 
   311   lua_pushvalue(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
   312   lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
   313   lua_settable(L, 2);
 | 
| 
jbe/bsw@0
 | 
   314   lua_settop(L, 1);
 | 
| 
jbe@23
 | 
   315   // store key "engine" with value "postgresql" as connection specific data:
 | 
| 
jbe/bsw@0
 | 
   316   lua_pushliteral(L, "postgresql");
 | 
| 
jbe/bsw@0
 | 
   317   lua_setfield(L, 1, "engine");
 | 
| 
jbe@23
 | 
   318   // return userdata:
 | 
| 
jbe/bsw@0
 | 
   319   return 1;
 | 
| 
jbe/bsw@0
 | 
   320 }
 | 
| 
jbe/bsw@0
 | 
   321 
 | 
| 
jbe@23
 | 
   322 // returns pointer to libpq handle 'pgconn' of userdata at given index
 | 
| 
jbe@23
 | 
   323 // (or throws error, if database connection has been closed):
 | 
| 
jbe/bsw@0
 | 
   324 static mondelefant_conn_t *mondelefant_get_conn(lua_State *L, int index) {
 | 
| 
jbe/bsw@0
 | 
   325   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   326   conn = luaL_checkudata(L, index, MONDELEFANT_CONN_MT_REGKEY);
 | 
| 
jbe/bsw@0
 | 
   327   if (!conn->pgconn) {
 | 
| 
jbe/bsw@0
 | 
   328     luaL_error(L, "PostgreSQL connection has been closed.");
 | 
| 
jbe/bsw@0
 | 
   329     return NULL;
 | 
| 
jbe/bsw@0
 | 
   330   }
 | 
| 
jbe/bsw@0
 | 
   331   return conn;
 | 
| 
jbe/bsw@0
 | 
   332 }
 | 
| 
jbe/bsw@0
 | 
   333 
 | 
| 
jbe@23
 | 
   334 // meta-method "__index" of database handles (userdata):
 | 
| 
jbe/bsw@0
 | 
   335 static int mondelefant_conn_index(lua_State *L) {
 | 
| 
jbe@23
 | 
   336   // try table for connection specific data:
 | 
| 
jbe/bsw@0
 | 
   337   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   338   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CONN_DATA_REGKEY);  // 3
 | 
| 
jbe/bsw@0
 | 
   339   lua_pushvalue(L, 1);  // 4
 | 
| 
jbe/bsw@0
 | 
   340   lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
   341   lua_remove(L, 3);  // connection specific data-table at stack position 3
 | 
| 
jbe/bsw@0
 | 
   342   lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
   343   lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
   344   if (!lua_isnil(L, 4)) return 1;
 | 
| 
jbe@23
 | 
   345   // try to use prototype stored in connection specific data:
 | 
| 
jbe/bsw@0
 | 
   346   lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
   347   lua_getfield(L, 3, "prototype");  // 4
 | 
| 
jbe/bsw@0
 | 
   348   if (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
   349     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
   350     lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
   351     if (!lua_isnil(L, 5)) return 1;
 | 
| 
jbe/bsw@0
 | 
   352   }
 | 
| 
jbe@23
 | 
   353   // try to use "postgresql_connection_prototype" of library:
 | 
| 
jbe/bsw@0
 | 
   354   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   355   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_MODULE_REGKEY);  // 3
 | 
| 
jbe/bsw@0
 | 
   356   lua_getfield(L, 3, "postgresql_connection_prototype");  // 4
 | 
| 
jbe/bsw@0
 | 
   357   if (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
   358     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
   359     lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
   360     if (!lua_isnil(L, 5)) return 1;
 | 
| 
jbe/bsw@0
 | 
   361   }
 | 
| 
jbe@23
 | 
   362   // try to use "connection_prototype" of library:
 | 
| 
jbe/bsw@0
 | 
   363   lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
   364   lua_getfield(L, 3, "connection_prototype");  // 4
 | 
| 
jbe/bsw@0
 | 
   365   if (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
   366     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
   367     lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
   368     if (!lua_isnil(L, 5)) return 1;
 | 
| 
jbe/bsw@0
 | 
   369   }
 | 
| 
jbe@23
 | 
   370   // give up and return nothing:
 | 
| 
jbe/bsw@0
 | 
   371   return 0;
 | 
| 
jbe/bsw@0
 | 
   372 }
 | 
| 
jbe/bsw@0
 | 
   373 
 | 
| 
jbe@23
 | 
   374 // meta-method "__newindex" of database handles (userdata):
 | 
| 
jbe/bsw@0
 | 
   375 static int mondelefant_conn_newindex(lua_State *L) {
 | 
| 
jbe@23
 | 
   376   // store key-value pair in table for connection specific data:
 | 
| 
jbe/bsw@0
 | 
   377   lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
   378   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CONN_DATA_REGKEY);  // 4
 | 
| 
jbe/bsw@0
 | 
   379   lua_pushvalue(L, 1);  // 5
 | 
| 
jbe/bsw@0
 | 
   380   lua_gettable(L, 4);  // 5
 | 
| 
jbe@23
 | 
   381   lua_remove(L, 4);  // connection specific data-table at stack position 4
 | 
| 
jbe/bsw@0
 | 
   382   lua_pushvalue(L, 2);
 | 
| 
jbe/bsw@0
 | 
   383   lua_pushvalue(L, 3);
 | 
| 
jbe/bsw@0
 | 
   384   lua_settable(L, 4);
 | 
| 
jbe@23
 | 
   385   // return nothing:
 | 
| 
jbe/bsw@0
 | 
   386   return 0;
 | 
| 
jbe/bsw@0
 | 
   387 }
 | 
| 
jbe/bsw@0
 | 
   388 
 | 
| 
jbe@23
 | 
   389 // meta-method "__gc" of database handles:
 | 
| 
jbe/bsw@0
 | 
   390 static int mondelefant_conn_free(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   391   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   392   conn = luaL_checkudata(L, 1, MONDELEFANT_CONN_MT_REGKEY);
 | 
| 
jbe/bsw@0
 | 
   393   if (conn->pgconn) PQfinish(conn->pgconn);
 | 
| 
jbe/bsw@0
 | 
   394   conn->pgconn = NULL;
 | 
| 
jbe/bsw@0
 | 
   395   return 0;
 | 
| 
jbe/bsw@0
 | 
   396 }
 | 
| 
jbe/bsw@0
 | 
   397 
 | 
| 
jbe@23
 | 
   398 // method "close" of database handles:
 | 
| 
jbe/bsw@0
 | 
   399 static int mondelefant_conn_close(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   400   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   401   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
   402   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe/bsw@0
 | 
   403   PQfinish(conn->pgconn);
 | 
| 
jbe/bsw@0
 | 
   404   conn->pgconn = NULL;
 | 
| 
jbe/bsw@0
 | 
   405   return 0;
 | 
| 
jbe/bsw@0
 | 
   406 }
 | 
| 
jbe/bsw@0
 | 
   407 
 | 
| 
jbe@23
 | 
   408 // method "is_okay" of database handles:
 | 
| 
jbe/bsw@0
 | 
   409 static int mondelefant_conn_is_ok(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   410   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   411   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
   412   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe/bsw@0
 | 
   413   lua_pushboolean(L, PQstatus(conn->pgconn) == CONNECTION_OK);
 | 
| 
jbe/bsw@0
 | 
   414   return 1;
 | 
| 
jbe/bsw@0
 | 
   415 }
 | 
| 
jbe/bsw@0
 | 
   416 
 | 
| 
jbe@23
 | 
   417 // method "get_transaction_status" of database handles:
 | 
| 
jbe/bsw@0
 | 
   418 static int mondelefant_conn_get_transaction_status(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   419   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   420   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
   421   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe/bsw@0
 | 
   422   switch (PQtransactionStatus(conn->pgconn)) {
 | 
| 
jbe/bsw@0
 | 
   423   case PQTRANS_IDLE:
 | 
| 
jbe/bsw@0
 | 
   424     lua_pushliteral(L, "idle");
 | 
| 
jbe/bsw@0
 | 
   425     break;
 | 
| 
jbe/bsw@0
 | 
   426   case PQTRANS_ACTIVE:
 | 
| 
jbe/bsw@0
 | 
   427     lua_pushliteral(L, "active");
 | 
| 
jbe/bsw@0
 | 
   428     break;
 | 
| 
jbe/bsw@0
 | 
   429   case PQTRANS_INTRANS:
 | 
| 
jbe/bsw@0
 | 
   430     lua_pushliteral(L, "intrans");
 | 
| 
jbe/bsw@0
 | 
   431     break;
 | 
| 
jbe/bsw@0
 | 
   432   case PQTRANS_INERROR:
 | 
| 
jbe/bsw@0
 | 
   433     lua_pushliteral(L, "inerror");
 | 
| 
jbe/bsw@0
 | 
   434     break;
 | 
| 
jbe/bsw@0
 | 
   435   default:
 | 
| 
jbe/bsw@0
 | 
   436     lua_pushliteral(L, "unknown");
 | 
| 
jbe/bsw@0
 | 
   437   }
 | 
| 
jbe/bsw@0
 | 
   438   return 1;
 | 
| 
jbe/bsw@0
 | 
   439 }
 | 
| 
jbe/bsw@0
 | 
   440 
 | 
| 
jbe@23
 | 
   441 // method "create_list" of database handles:
 | 
| 
jbe/bsw@0
 | 
   442 static int mondelefant_conn_create_list(lua_State *L) {
 | 
| 
jbe@23
 | 
   443   // ensure that first argument is a database connection:
 | 
| 
jbe/bsw@0
 | 
   444   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   445   luaL_checkudata(L, 1, MONDELEFANT_CONN_MT_REGKEY);
 | 
| 
jbe@23
 | 
   446   // if no second argument is given, use an empty table:
 | 
| 
jbe/bsw@0
 | 
   447   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
   448     lua_newtable(L);
 | 
| 
jbe/bsw@0
 | 
   449     lua_replace(L, 2);  // new result at stack position 2
 | 
| 
jbe/bsw@0
 | 
   450   }
 | 
| 
jbe@23
 | 
   451   // set meta-table for database result lists/objects:
 | 
| 
jbe/bsw@0
 | 
   452   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_RESULT_MT_REGKEY);  // 3
 | 
| 
jbe/bsw@0
 | 
   453   lua_setmetatable(L, 2);
 | 
| 
jbe@23
 | 
   454   // set "_connection" attribute to self:
 | 
| 
jbe/bsw@0
 | 
   455   lua_pushvalue(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
   456   lua_setfield(L, 2, "_connection");
 | 
| 
jbe@23
 | 
   457   // set "_type" attribute to string "list":
 | 
| 
jbe/bsw@0
 | 
   458   lua_pushliteral(L, "list");  // 3
 | 
| 
jbe/bsw@0
 | 
   459   lua_setfield(L, 2, "_type");
 | 
| 
jbe@23
 | 
   460   // return created database result list:
 | 
| 
jbe/bsw@0
 | 
   461   return 1;
 | 
| 
jbe/bsw@0
 | 
   462 }
 | 
| 
jbe/bsw@0
 | 
   463 
 | 
| 
jbe@23
 | 
   464 // method "create_object" of database handles:
 | 
| 
jbe/bsw@0
 | 
   465 static int mondelefant_conn_create_object(lua_State *L) {
 | 
| 
jbe@23
 | 
   466   // ensure that first argument is a database connection:
 | 
| 
jbe/bsw@0
 | 
   467   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   468   luaL_checkudata(L, 1, MONDELEFANT_CONN_MT_REGKEY);
 | 
| 
jbe@23
 | 
   469   // if no second argument is given, use an empty table:
 | 
| 
jbe/bsw@0
 | 
   470   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
   471     lua_newtable(L);
 | 
| 
jbe/bsw@0
 | 
   472     lua_replace(L, 2);  // new result at stack position 2
 | 
| 
jbe/bsw@0
 | 
   473   }
 | 
| 
jbe@23
 | 
   474   //   set meta-table for database result lists/objects:
 | 
| 
jbe/bsw@0
 | 
   475   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_RESULT_MT_REGKEY);  // 3
 | 
| 
jbe/bsw@0
 | 
   476   lua_setmetatable(L, 2);
 | 
| 
jbe@23
 | 
   477   // set "_connection" attribute to self:
 | 
| 
jbe/bsw@0
 | 
   478   lua_pushvalue(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
   479   lua_setfield(L, 2, "_connection");
 | 
| 
jbe@23
 | 
   480   // set "_type" attribute to string "object":
 | 
| 
jbe/bsw@0
 | 
   481   lua_pushliteral(L, "object");  // 3
 | 
| 
jbe/bsw@0
 | 
   482   lua_setfield(L, 2, "_type");  // "object" or "list"
 | 
| 
jbe@23
 | 
   483   // create empty tables for "_data", "_dirty" and "_ref" attributes:
 | 
| 
jbe/bsw@0
 | 
   484   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
   485   lua_setfield(L, 2, "_data");
 | 
| 
jbe/bsw@0
 | 
   486   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
   487   lua_setfield(L, 2, "_dirty");
 | 
| 
jbe/bsw@0
 | 
   488   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
   489   lua_setfield(L, 2, "_ref");  // nil=no info, false=nil, else table
 | 
| 
jbe@23
 | 
   490   // return created database result object:
 | 
| 
jbe/bsw@0
 | 
   491   return 1;
 | 
| 
jbe/bsw@0
 | 
   492 }
 | 
| 
jbe/bsw@0
 | 
   493 
 | 
| 
jbe@23
 | 
   494 // method "quote_string" of database handles:
 | 
| 
jbe/bsw@0
 | 
   495 static int mondelefant_conn_quote_string(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   496   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   497   const char *input;
 | 
| 
jbe/bsw@0
 | 
   498   size_t input_len;
 | 
| 
jbe/bsw@0
 | 
   499   char *output;
 | 
| 
jbe/bsw@0
 | 
   500   size_t output_len;
 | 
| 
jbe@23
 | 
   501   // get 'conn' attribute of C-struct of database connection:
 | 
| 
jbe/bsw@0
 | 
   502   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   503   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe@23
 | 
   504   // get second argument, which must be a string:
 | 
| 
jbe/bsw@0
 | 
   505   input = luaL_checklstring(L, 2, &input_len);
 | 
| 
jbe@23
 | 
   506   // throw error, if string is too long:
 | 
| 
jbe/bsw@0
 | 
   507   if (input_len > (SIZE_MAX / sizeof(char) - 3) / 2) {
 | 
| 
jbe/bsw@0
 | 
   508     return luaL_error(L, "String to be escaped is too long.");
 | 
| 
jbe/bsw@0
 | 
   509   }
 | 
| 
jbe@23
 | 
   510   // allocate memory for quoted string:
 | 
| 
jbe/bsw@0
 | 
   511   output = malloc((2 * input_len + 3) * sizeof(char));
 | 
| 
jbe/bsw@0
 | 
   512   if (!output) {
 | 
| 
jbe/bsw@0
 | 
   513     return luaL_error(L, "Could not allocate memory for string quoting.");
 | 
| 
jbe/bsw@0
 | 
   514   }
 | 
| 
jbe@23
 | 
   515   // do escaping by calling PQescapeStringConn and enclosing result with
 | 
| 
jbe@23
 | 
   516   // single quotes:
 | 
| 
jbe/bsw@0
 | 
   517   output[0] = '\'';
 | 
| 
jbe/bsw@0
 | 
   518   output_len = PQescapeStringConn(
 | 
| 
jbe/bsw@0
 | 
   519     conn->pgconn, output + 1, input, input_len, NULL
 | 
| 
jbe/bsw@0
 | 
   520   );
 | 
| 
jbe/bsw@0
 | 
   521   output[output_len + 1] = '\'';
 | 
| 
jbe/bsw@0
 | 
   522   output[output_len + 2] = 0;
 | 
| 
jbe@23
 | 
   523   // create Lua string:
 | 
| 
jbe/bsw@0
 | 
   524   lua_pushlstring(L, output, output_len + 2);
 | 
| 
jbe@23
 | 
   525   // free allocated memory:
 | 
| 
jbe/bsw@0
 | 
   526   free(output);
 | 
| 
jbe@23
 | 
   527   // return Lua string:
 | 
| 
jbe/bsw@0
 | 
   528   return 1;
 | 
| 
jbe/bsw@0
 | 
   529 }
 | 
| 
jbe/bsw@0
 | 
   530 
 | 
| 
jbe@23
 | 
   531 // method "quote_binary" of database handles:
 | 
| 
jbe/bsw@0
 | 
   532 static int mondelefant_conn_quote_binary(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   533   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   534   const char *input;
 | 
| 
jbe/bsw@0
 | 
   535   size_t input_len;
 | 
| 
jbe/bsw@0
 | 
   536   char *output;
 | 
| 
jbe/bsw@0
 | 
   537   size_t output_len;
 | 
| 
jbe/bsw@0
 | 
   538   luaL_Buffer buf;
 | 
| 
jbe@23
 | 
   539   // get 'conn' attribute of C-struct of database connection:
 | 
| 
jbe/bsw@0
 | 
   540   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   541   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe@23
 | 
   542   // get second argument, which must be a string:
 | 
| 
jbe/bsw@0
 | 
   543   input = luaL_checklstring(L, 2, &input_len);
 | 
| 
jbe@23
 | 
   544   // call PQescapeByteaConn, which allocates memory itself:
 | 
| 
jbe/bsw@0
 | 
   545   output = (char *)PQescapeByteaConn(
 | 
| 
jbe/bsw@0
 | 
   546     conn->pgconn, (const unsigned char *)input, input_len, &output_len
 | 
| 
jbe/bsw@0
 | 
   547   );
 | 
| 
jbe@23
 | 
   548   // if PQescapeByteaConn returned NULL, then throw error:
 | 
| 
jbe/bsw@0
 | 
   549   if (!output) {
 | 
| 
jbe/bsw@0
 | 
   550     return luaL_error(L, "Could not allocate memory for binary quoting.");
 | 
| 
jbe/bsw@0
 | 
   551   }
 | 
| 
jbe@23
 | 
   552   // create Lua string enclosed by single quotes:
 | 
| 
jbe/bsw@0
 | 
   553   luaL_buffinit(L, &buf);
 | 
| 
jbe/bsw@0
 | 
   554   luaL_addchar(&buf, '\'');
 | 
| 
jbe/bsw@0
 | 
   555   luaL_addlstring(&buf, output, output_len - 1);
 | 
| 
jbe/bsw@0
 | 
   556   luaL_addchar(&buf, '\'');
 | 
| 
jbe/bsw@0
 | 
   557   luaL_pushresult(&buf);
 | 
| 
jbe@23
 | 
   558   // free memory allocated by PQescapeByteaConn:
 | 
| 
jbe/bsw@0
 | 
   559   PQfreemem(output);
 | 
| 
jbe@23
 | 
   560   // return Lua string:
 | 
| 
jbe/bsw@0
 | 
   561   return 1;
 | 
| 
jbe/bsw@0
 | 
   562 }
 | 
| 
jbe/bsw@0
 | 
   563 
 | 
| 
jbe@23
 | 
   564 // method "assemble_command" of database handles:
 | 
| 
jbe/bsw@0
 | 
   565 static int mondelefant_conn_assemble_command(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   566   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   567   int paramidx = 2;
 | 
| 
jbe/bsw@0
 | 
   568   const char *template;
 | 
| 
jbe/bsw@0
 | 
   569   size_t template_pos = 0;
 | 
| 
jbe/bsw@0
 | 
   570   luaL_Buffer buf;
 | 
| 
jbe@23
 | 
   571   // get 'conn' attribute of C-struct of database connection:
 | 
| 
jbe/bsw@0
 | 
   572   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   573   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe@23
 | 
   574   // if second argument is a string, return this string:
 | 
| 
jbe/bsw@0
 | 
   575   if (lua_isstring(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
   576     lua_tostring(L, 2);
 | 
| 
jbe/bsw@0
 | 
   577     return 1;
 | 
| 
jbe/bsw@0
 | 
   578   }
 | 
| 
jbe@23
 | 
   579   // if second argument has __tostring meta-method,
 | 
| 
jbe@23
 | 
   580   // then use this method and return its result:
 | 
| 
jbe/bsw@0
 | 
   581   if (luaL_callmeta(L, 2, "__tostring")) return 1;
 | 
| 
jbe@23
 | 
   582   // otherwise, require that second argument is a table:
 | 
| 
jbe/bsw@0
 | 
   583   luaL_checktype(L, 2, LUA_TTABLE);
 | 
| 
jbe@23
 | 
   584   // get first element of table, which must be a string:
 | 
| 
jbe/bsw@0
 | 
   585   lua_rawgeti(L, 2, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
   586   luaL_argcheck(L,
 | 
| 
jbe/bsw@0
 | 
   587     lua_isstring(L, 3),
 | 
| 
jbe/bsw@0
 | 
   588     2,
 | 
| 
jbe/bsw@0
 | 
   589     "First entry of SQL command structure is not a string."
 | 
| 
jbe/bsw@0
 | 
   590   );
 | 
| 
jbe/bsw@0
 | 
   591   template = lua_tostring(L, 3);
 | 
| 
jbe@23
 | 
   592   // get value of "input_converter" attribute of database connection:
 | 
| 
jbe/bsw@0
 | 
   593   lua_pushliteral(L, "input_converter");  // 4
 | 
| 
jbe/bsw@0
 | 
   594   lua_gettable(L, 1);  // input_converter at stack position 4
 | 
| 
jbe@23
 | 
   595   // reserve space on Lua stack:
 | 
| 
jbe/bsw@0
 | 
   596   lua_pushnil(L);  // free space at stack position 5
 | 
| 
jbe/bsw@0
 | 
   597   lua_pushnil(L);  // free space at stack position 6
 | 
| 
jbe@23
 | 
   598   // initialize Lua buffer for result string:
 | 
| 
jbe/bsw@0
 | 
   599   luaL_buffinit(L, &buf);
 | 
| 
jbe@23
 | 
   600   // fill buffer in loop:
 | 
| 
jbe/bsw@0
 | 
   601   while (1) {
 | 
| 
jbe@23
 | 
   602     // variable declaration:
 | 
| 
jbe/bsw@0
 | 
   603     char c;
 | 
| 
jbe@23
 | 
   604     // get next character:
 | 
| 
jbe/bsw@0
 | 
   605     c = template[template_pos++];
 | 
| 
jbe@23
 | 
   606     // break, when character is NULL byte:
 | 
| 
jbe/bsw@0
 | 
   607     if (!c) break;
 | 
| 
jbe@23
 | 
   608     // question-mark and dollar-sign are special characters:
 | 
| 
jbe@23
 | 
   609     if (c == '?' || c == '$') {  // special character found
 | 
| 
jbe@23
 | 
   610       // check, if same character follows:
 | 
| 
jbe@23
 | 
   611       if (template[template_pos] == c) {  // special character is escaped
 | 
| 
jbe@23
 | 
   612         // consume two characters of input and add one character to buffer:
 | 
| 
jbe/bsw@0
 | 
   613         template_pos++;
 | 
| 
jbe/bsw@0
 | 
   614         luaL_addchar(&buf, c);
 | 
| 
jbe@23
 | 
   615       } else {  // special character is not escaped
 | 
| 
jbe/bsw@0
 | 
   616         luaL_Buffer keybuf;
 | 
| 
jbe/bsw@0
 | 
   617         int subcmd;
 | 
| 
jbe@23
 | 
   618         // set 'subcmd' = true, if special character was a dollar-sign,
 | 
| 
jbe@23
 | 
   619         // set 'subcmd' = false, if special character was a question-mark:
 | 
| 
jbe/bsw@0
 | 
   620         subcmd = (c == '$');
 | 
| 
jbe@23
 | 
   621         // read any number of alpha numeric chars or underscores
 | 
| 
jbe@23
 | 
   622         // and store them on Lua stack:
 | 
| 
jbe/bsw@0
 | 
   623         luaL_buffinit(L, &keybuf);
 | 
| 
jbe/bsw@0
 | 
   624         while (1) {
 | 
| 
jbe/bsw@0
 | 
   625           c = template[template_pos];
 | 
| 
jbe/bsw@0
 | 
   626           if (
 | 
| 
jbe/bsw@0
 | 
   627             (c < 'A' || c > 'Z') &&
 | 
| 
jbe/bsw@0
 | 
   628             (c < 'a' || c > 'z') &&
 | 
| 
jbe/bsw@0
 | 
   629             (c < '0' || c > '9') &&
 | 
| 
jbe/bsw@0
 | 
   630             (c != '_')
 | 
| 
jbe/bsw@0
 | 
   631           ) break;
 | 
| 
jbe/bsw@0
 | 
   632           luaL_addchar(&keybuf, c);
 | 
| 
jbe/bsw@0
 | 
   633           template_pos++;
 | 
| 
jbe/bsw@0
 | 
   634         }
 | 
| 
jbe/bsw@0
 | 
   635         luaL_pushresult(&keybuf);
 | 
| 
jbe@23
 | 
   636         // check, if any characters matched:
 | 
| 
jbe@64
 | 
   637 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
   638         if (lua_rawlen(L, -1)) {
 | 
| 
jbe@64
 | 
   639 #else
 | 
| 
jbe/bsw@0
 | 
   640         if (lua_objlen(L, -1)) {
 | 
| 
jbe@64
 | 
   641 #endif
 | 
| 
jbe@23
 | 
   642           // if any alpha numeric chars or underscores were found,
 | 
| 
jbe@23
 | 
   643           // push them on stack as a Lua string and use them to lookup
 | 
| 
jbe@23
 | 
   644           // value from second argument:
 | 
| 
jbe/bsw@0
 | 
   645           lua_pushvalue(L, -1);           // save key on stack
 | 
| 
jbe@23
 | 
   646           lua_gettable(L, 2);             // fetch value (raw-value)
 | 
| 
jbe/bsw@0
 | 
   647         } else {
 | 
| 
jbe@23
 | 
   648           // otherwise push nil and use numeric lookup based on 'paramidx':
 | 
| 
jbe/bsw@0
 | 
   649           lua_pop(L, 1);
 | 
| 
jbe/bsw@0
 | 
   650           lua_pushnil(L);                 // put nil on key position
 | 
| 
jbe@23
 | 
   651           lua_rawgeti(L, 2, paramidx++);  // fetch value (raw-value)
 | 
| 
jbe/bsw@0
 | 
   652         }
 | 
| 
jbe@23
 | 
   653         // Lua stack contains: ..., <buffer>, key, raw-value
 | 
| 
jbe@23
 | 
   654         // branch according to type of special character ("?" or "$"):
 | 
| 
jbe@23
 | 
   655         if (subcmd) {  // dollar-sign
 | 
| 
jbe/bsw@0
 | 
   656           size_t i;
 | 
| 
jbe/bsw@0
 | 
   657           size_t count;
 | 
| 
jbe@23
 | 
   658           // store fetched value (which is supposed to be sub-structure)
 | 
| 
jbe@23
 | 
   659           // on Lua stack position 5 and drop key:
 | 
| 
jbe@23
 | 
   660           lua_replace(L, 5);
 | 
| 
jbe@23
 | 
   661           lua_pop(L, 1);
 | 
| 
jbe@23
 | 
   662           // Lua stack contains: ..., <buffer>
 | 
| 
jbe@23
 | 
   663           // check, if fetched value is really a sub-structure:
 | 
| 
jbe/bsw@0
 | 
   664           luaL_argcheck(L,
 | 
| 
jbe/bsw@0
 | 
   665             !lua_isnil(L, 5),
 | 
| 
jbe/bsw@0
 | 
   666             2,
 | 
| 
jbe/bsw@0
 | 
   667             "SQL sub-structure not found."
 | 
| 
jbe/bsw@0
 | 
   668           );
 | 
| 
jbe/bsw@0
 | 
   669           luaL_argcheck(L,
 | 
| 
jbe/bsw@0
 | 
   670             lua_type(L, 5) == LUA_TTABLE,
 | 
| 
jbe/bsw@0
 | 
   671             2,
 | 
| 
jbe/bsw@0
 | 
   672             "SQL sub-structure must be a table."
 | 
| 
jbe/bsw@0
 | 
   673           );
 | 
| 
jbe@23
 | 
   674           // Lua stack contains: ..., <buffer>
 | 
| 
jbe@23
 | 
   675           // get value of "sep" attribute of sub-structure,
 | 
| 
jbe@23
 | 
   676           // and place it on Lua stack position 6:
 | 
| 
jbe/bsw@0
 | 
   677           lua_getfield(L, 5, "sep");
 | 
| 
jbe@23
 | 
   678           lua_replace(L, 6);
 | 
| 
jbe@23
 | 
   679           // if seperator is nil, then use ", " as default,
 | 
| 
jbe@23
 | 
   680           // if seperator is neither nil nor a string, then throw error:
 | 
| 
jbe/bsw@0
 | 
   681           if (lua_isnil(L, 6)) {
 | 
| 
jbe/bsw@0
 | 
   682             lua_pushstring(L, ", ");
 | 
| 
jbe/bsw@0
 | 
   683             lua_replace(L, 6);
 | 
| 
jbe/bsw@0
 | 
   684           } else {
 | 
| 
jbe/bsw@0
 | 
   685             luaL_argcheck(L,
 | 
| 
jbe/bsw@0
 | 
   686               lua_isstring(L, 6),
 | 
| 
jbe/bsw@0
 | 
   687               2,
 | 
| 
jbe/bsw@0
 | 
   688               "Seperator of SQL sub-structure has to be a string."
 | 
| 
jbe/bsw@0
 | 
   689             );
 | 
| 
jbe/bsw@0
 | 
   690           }
 | 
| 
jbe@23
 | 
   691           // iterate over items of sub-structure:
 | 
| 
jbe@64
 | 
   692 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
   693           count = lua_rawlen(L, 5);
 | 
| 
jbe@64
 | 
   694 #else
 | 
| 
jbe/bsw@0
 | 
   695           count = lua_objlen(L, 5);
 | 
| 
jbe@64
 | 
   696 #endif
 | 
| 
jbe/bsw@0
 | 
   697           for (i = 0; i < count; i++) {
 | 
| 
jbe@23
 | 
   698             // add seperator, unless this is the first run:
 | 
| 
jbe/bsw@0
 | 
   699             if (i) {
 | 
| 
jbe/bsw@0
 | 
   700               lua_pushvalue(L, 6);
 | 
| 
jbe/bsw@0
 | 
   701               luaL_addvalue(&buf);
 | 
| 
jbe/bsw@0
 | 
   702             }
 | 
| 
jbe@23
 | 
   703             // recursivly apply assemble function and add results to buffer:
 | 
| 
jbe/bsw@0
 | 
   704             lua_pushcfunction(L, mondelefant_conn_assemble_command);
 | 
| 
jbe/bsw@0
 | 
   705             lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
   706             lua_rawgeti(L, 5, i+1);
 | 
| 
jbe/bsw@0
 | 
   707             lua_call(L, 2, 1);
 | 
| 
jbe/bsw@0
 | 
   708             luaL_addvalue(&buf);
 | 
| 
jbe/bsw@0
 | 
   709           }
 | 
| 
jbe@23
 | 
   710         } else {  // question-mark
 | 
| 
jbe/bsw@0
 | 
   711           if (lua_toboolean(L, 4)) {
 | 
| 
jbe@23
 | 
   712             // call input_converter with connection handle, raw-value and
 | 
| 
jbe@23
 | 
   713             // an info-table which contains a "field_name" entry with the
 | 
| 
jbe@23
 | 
   714             // used key:
 | 
| 
jbe/bsw@0
 | 
   715             lua_pushvalue(L, 4);
 | 
| 
jbe/bsw@0
 | 
   716             lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
   717             lua_pushvalue(L, -3);
 | 
| 
jbe/bsw@0
 | 
   718             lua_newtable(L);
 | 
| 
jbe/bsw@0
 | 
   719             lua_pushvalue(L, -6);
 | 
| 
jbe/bsw@0
 | 
   720             lua_setfield(L, -2, "field_name");
 | 
| 
jbe/bsw@0
 | 
   721             lua_call(L, 3, 1);
 | 
| 
jbe@23
 | 
   722             // Lua stack contains: ..., <buffer>, key, raw-value, final-value
 | 
| 
jbe@23
 | 
   723             // remove key and raw-value:
 | 
| 
jbe/bsw@0
 | 
   724             lua_remove(L, -2);
 | 
| 
jbe/bsw@0
 | 
   725             lua_remove(L, -2);
 | 
| 
jbe@23
 | 
   726             // Lua stack contains: ..., <buffer>, final-value
 | 
| 
jbe@23
 | 
   727             // throw error, if final-value is not a string:
 | 
| 
jbe/bsw@0
 | 
   728             if (!lua_isstring(L, -1)) {
 | 
| 
jbe/bsw@0
 | 
   729               return luaL_error(L, "input_converter returned non-string.");
 | 
| 
jbe/bsw@0
 | 
   730             }
 | 
| 
jbe/bsw@0
 | 
   731           } else {
 | 
| 
jbe@23
 | 
   732             // remove key from stack:
 | 
| 
jbe/bsw@0
 | 
   733             lua_remove(L, -2);
 | 
| 
jbe@23
 | 
   734             // Lua stack contains: ..., <buffer>, raw-value
 | 
| 
jbe@23
 | 
   735             // branch according to type of value:
 | 
| 
jbe@23
 | 
   736             if (lua_isnil(L, -1)) {  // value is nil
 | 
| 
jbe@23
 | 
   737               // push string "NULL" to stack:
 | 
| 
jbe/bsw@0
 | 
   738               lua_pushliteral(L, "NULL");
 | 
| 
jbe@23
 | 
   739             } else if (lua_type(L, -1) == LUA_TBOOLEAN) {  // value is boolean
 | 
| 
jbe@23
 | 
   740               // push strings "TRUE" or "FALSE" to stack:
 | 
| 
jbe/bsw@0
 | 
   741               lua_pushstring(L, lua_toboolean(L, -1) ? "TRUE" : "FALSE");
 | 
| 
jbe@23
 | 
   742             } else if (lua_isstring(L, -1)) {  // value is string or number
 | 
| 
jbe/bsw@0
 | 
   743               // NOTE: In this version of lua a number will be converted
 | 
| 
jbe@23
 | 
   744               // push output of "quote_string" method of database
 | 
| 
jbe@23
 | 
   745               // connection to stack:
 | 
| 
jbe/bsw@0
 | 
   746               lua_tostring(L, -1);
 | 
| 
jbe/bsw@0
 | 
   747               lua_pushcfunction(L, mondelefant_conn_quote_string);
 | 
| 
jbe/bsw@0
 | 
   748               lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
   749               lua_pushvalue(L, -3);
 | 
| 
jbe/bsw@0
 | 
   750               lua_call(L, 2, 1);
 | 
| 
jbe@23
 | 
   751             } else {  // value is of other type
 | 
| 
jbe@23
 | 
   752               // throw error:
 | 
| 
jbe/bsw@0
 | 
   753               return luaL_error(L,
 | 
| 
jbe/bsw@0
 | 
   754                 "Unable to convert SQL value due to unknown type "
 | 
| 
jbe/bsw@0
 | 
   755                 "or missing input_converter."
 | 
| 
jbe/bsw@0
 | 
   756               );
 | 
| 
jbe/bsw@0
 | 
   757             }
 | 
| 
jbe@23
 | 
   758             // Lua stack contains: ..., <buffer>, raw-value, final-value
 | 
| 
jbe@23
 | 
   759             // remove raw-value:
 | 
| 
jbe/bsw@0
 | 
   760             lua_remove(L, -2);
 | 
| 
jbe@23
 | 
   761             // Lua stack contains: ..., <buffer>, final-value
 | 
| 
jbe/bsw@0
 | 
   762           }
 | 
| 
jbe@23
 | 
   763           // append final-value to buffer:
 | 
| 
jbe/bsw@0
 | 
   764           luaL_addvalue(&buf);
 | 
| 
jbe/bsw@0
 | 
   765         }
 | 
| 
jbe/bsw@0
 | 
   766       }
 | 
| 
jbe@23
 | 
   767     } else {  // character is not special
 | 
| 
jbe@23
 | 
   768       // just copy character:
 | 
| 
jbe/bsw@0
 | 
   769       luaL_addchar(&buf, c);
 | 
| 
jbe/bsw@0
 | 
   770     }
 | 
| 
jbe/bsw@0
 | 
   771   }
 | 
| 
jbe@23
 | 
   772   // return string in buffer:
 | 
| 
jbe/bsw@0
 | 
   773   luaL_pushresult(&buf);
 | 
| 
jbe/bsw@0
 | 
   774   return 1;
 | 
| 
jbe/bsw@0
 | 
   775 }
 | 
| 
jbe/bsw@0
 | 
   776 
 | 
| 
jbe@23
 | 
   777 // max number of SQL statements executed by one "query" method call:
 | 
| 
jbe/bsw@0
 | 
   778 #define MONDELEFANT_MAX_COMMAND_COUNT 64
 | 
| 
jbe@23
 | 
   779 // max number of columns in a database result:
 | 
| 
jbe/bsw@0
 | 
   780 #define MONDELEFANT_MAX_COLUMN_COUNT 1024
 | 
| 
jbe@23
 | 
   781 // enum values for 'modes' array in C-function below:
 | 
| 
jbe/bsw@0
 | 
   782 #define MONDELEFANT_QUERY_MODE_LIST 1
 | 
| 
jbe/bsw@0
 | 
   783 #define MONDELEFANT_QUERY_MODE_OBJECT 2
 | 
| 
jbe/bsw@0
 | 
   784 #define MONDELEFANT_QUERY_MODE_OPT_OBJECT 3
 | 
| 
jbe/bsw@0
 | 
   785 
 | 
| 
jbe@23
 | 
   786 // method "try_query" of database handles:
 | 
| 
jbe/bsw@0
 | 
   787 static int mondelefant_conn_try_query(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
   788   mondelefant_conn_t *conn;
 | 
| 
jbe/bsw@0
 | 
   789   int command_count;
 | 
| 
jbe/bsw@0
 | 
   790   int command_idx;
 | 
| 
jbe/bsw@0
 | 
   791   int modes[MONDELEFANT_MAX_COMMAND_COUNT];
 | 
| 
jbe/bsw@0
 | 
   792   luaL_Buffer buf;
 | 
| 
jbe/bsw@0
 | 
   793   int sent_success;
 | 
| 
jbe/bsw@0
 | 
   794   PGresult *res;
 | 
| 
jbe/bsw@0
 | 
   795   int rows, cols, row, col;
 | 
| 
jbe@23
 | 
   796   // get 'conn' attribute of C-struct of database connection:
 | 
| 
jbe/bsw@0
 | 
   797   conn = mondelefant_get_conn(L, 1);
 | 
| 
jbe@23
 | 
   798   // calculate number of commands (2 arguments for one command):
 | 
| 
jbe/bsw@0
 | 
   799   command_count = lua_gettop(L) / 2;
 | 
| 
jbe@23
 | 
   800   // push nil on stack, which is needed, if last mode was ommitted:
 | 
| 
jbe@23
 | 
   801   lua_pushnil(L);
 | 
| 
jbe@23
 | 
   802   // throw error, if number of commands is too high:
 | 
| 
jbe/bsw@0
 | 
   803   if (command_count > MONDELEFANT_MAX_COMMAND_COUNT) {
 | 
| 
jbe/bsw@0
 | 
   804     return luaL_error(L, "Exceeded maximum command count in one query.");
 | 
| 
jbe/bsw@0
 | 
   805   }
 | 
| 
jbe@23
 | 
   806   // create SQL string, store query modes and push SQL string on stack:
 | 
| 
jbe/bsw@0
 | 
   807   luaL_buffinit(L, &buf);
 | 
| 
jbe/bsw@0
 | 
   808   for (command_idx = 0; command_idx < command_count; command_idx++) {
 | 
| 
jbe/bsw@0
 | 
   809     int mode;
 | 
| 
jbe/bsw@0
 | 
   810     int mode_idx;  // stack index of mode string
 | 
| 
jbe/bsw@0
 | 
   811     if (command_idx) luaL_addchar(&buf, ' ');
 | 
| 
jbe/bsw@0
 | 
   812     lua_pushcfunction(L, mondelefant_conn_assemble_command);
 | 
| 
jbe/bsw@0
 | 
   813     lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
   814     lua_pushvalue(L, 2 + 2 * command_idx);
 | 
| 
jbe/bsw@0
 | 
   815     lua_call(L, 2, 1);
 | 
| 
jbe/bsw@0
 | 
   816     luaL_addvalue(&buf);
 | 
| 
jbe/bsw@0
 | 
   817     luaL_addchar(&buf, ';');
 | 
| 
jbe/bsw@0
 | 
   818     mode_idx = 3 + 2 * command_idx;
 | 
| 
jbe/bsw@0
 | 
   819     if (lua_isnil(L, mode_idx)) {
 | 
| 
jbe/bsw@0
 | 
   820       mode = MONDELEFANT_QUERY_MODE_LIST;
 | 
| 
jbe/bsw@0
 | 
   821     } else {
 | 
| 
jbe/bsw@0
 | 
   822       const char *modestr;
 | 
| 
jbe/bsw@0
 | 
   823       modestr = luaL_checkstring(L, mode_idx);
 | 
| 
jbe/bsw@0
 | 
   824       if (!strcmp(modestr, "list")) {
 | 
| 
jbe/bsw@0
 | 
   825         mode = MONDELEFANT_QUERY_MODE_LIST;
 | 
| 
jbe/bsw@0
 | 
   826       } else if (!strcmp(modestr, "object")) {
 | 
| 
jbe/bsw@0
 | 
   827         mode = MONDELEFANT_QUERY_MODE_OBJECT;
 | 
| 
jbe/bsw@0
 | 
   828       } else if (!strcmp(modestr, "opt_object")) {
 | 
| 
jbe/bsw@0
 | 
   829         mode = MONDELEFANT_QUERY_MODE_OPT_OBJECT;
 | 
| 
jbe/bsw@0
 | 
   830       } else {
 | 
| 
jbe/bsw@0
 | 
   831         return luaL_error(L, "Unknown query mode specified.");
 | 
| 
jbe/bsw@0
 | 
   832       }
 | 
| 
jbe/bsw@0
 | 
   833     }
 | 
| 
jbe/bsw@0
 | 
   834     modes[command_idx] = mode;
 | 
| 
jbe/bsw@0
 | 
   835   }
 | 
| 
jbe/bsw@0
 | 
   836   luaL_pushresult(&buf);  // stack position unknown
 | 
| 
jbe/bsw@0
 | 
   837   lua_replace(L, 2);  // SQL command string to stack position 2
 | 
| 
jbe@23
 | 
   838   // call sql_tracer, if set:
 | 
| 
jbe/bsw@0
 | 
   839   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
   840   lua_getfield(L, 1, "sql_tracer");  // tracer at stack position 3
 | 
| 
jbe/bsw@0
 | 
   841   if (lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
   842     lua_pushvalue(L, 1);  // 4
 | 
| 
jbe/bsw@0
 | 
   843     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
   844     lua_call(L, 2, 1);  // trace callback at stack position 3
 | 
| 
jbe/bsw@0
 | 
   845   }
 | 
| 
jbe@23
 | 
   846   // NOTE: If no tracer was found, then nil or false is stored at stack
 | 
| 
jbe@23
 | 
   847   // position 3.
 | 
| 
jbe@23
 | 
   848   // call PQsendQuery function and store result in 'sent_success' variable:
 | 
| 
jbe/bsw@0
 | 
   849   sent_success = PQsendQuery(conn->pgconn, lua_tostring(L, 2));
 | 
| 
jbe@23
 | 
   850   // create preliminary result table:
 | 
| 
jbe/bsw@0
 | 
   851   lua_newtable(L);  // results in table at stack position 4
 | 
| 
jbe@23
 | 
   852   // iterate over results using function PQgetResult to fill result table:
 | 
| 
jbe/bsw@0
 | 
   853   for (command_idx = 0; ; command_idx++) {
 | 
| 
jbe/bsw@0
 | 
   854     int mode;
 | 
| 
jbe/bsw@0
 | 
   855     char binary[MONDELEFANT_MAX_COLUMN_COUNT];
 | 
| 
jbe/bsw@0
 | 
   856     ExecStatusType pgstatus;
 | 
| 
jbe@23
 | 
   857     // fetch mode which was given for the command:
 | 
| 
jbe/bsw@0
 | 
   858     mode = modes[command_idx];
 | 
| 
jbe@23
 | 
   859     // if PQsendQuery call was successful, then fetch result data:
 | 
| 
jbe/bsw@0
 | 
   860     if (sent_success) {
 | 
| 
jbe@23
 | 
   861       // NOTE: PQgetResult called one extra time. Break only, if all
 | 
| 
jbe@23
 | 
   862       // queries have been processed and PQgetResult returned NULL.
 | 
| 
jbe/bsw@0
 | 
   863       res = PQgetResult(conn->pgconn);
 | 
| 
jbe/bsw@0
 | 
   864       if (command_idx >= command_count && !res) break;
 | 
| 
jbe/bsw@0
 | 
   865       if (res) {
 | 
| 
jbe/bsw@0
 | 
   866         pgstatus = PQresultStatus(res);
 | 
| 
jbe/bsw@0
 | 
   867         rows = PQntuples(res);
 | 
| 
jbe/bsw@0
 | 
   868         cols = PQnfields(res);
 | 
| 
jbe/bsw@0
 | 
   869       }
 | 
| 
jbe/bsw@0
 | 
   870     }
 | 
| 
jbe@23
 | 
   871     // handle errors:
 | 
| 
jbe/bsw@0
 | 
   872     if (
 | 
| 
jbe/bsw@0
 | 
   873       !sent_success || command_idx >= command_count || !res ||
 | 
| 
jbe/bsw@0
 | 
   874       (pgstatus != PGRES_TUPLES_OK && pgstatus != PGRES_COMMAND_OK) ||
 | 
| 
jbe/bsw@0
 | 
   875       (rows < 1 && mode == MONDELEFANT_QUERY_MODE_OBJECT) ||
 | 
| 
jbe/bsw@0
 | 
   876       (rows > 1 && mode != MONDELEFANT_QUERY_MODE_LIST)
 | 
| 
jbe/bsw@0
 | 
   877     ) {
 | 
| 
jbe/bsw@0
 | 
   878       const char *command;
 | 
| 
jbe/bsw@0
 | 
   879       command = lua_tostring(L, 2);
 | 
| 
jbe/bsw@0
 | 
   880       lua_newtable(L);  // 5
 | 
| 
jbe/bsw@0
 | 
   881       lua_getfield(L,
 | 
| 
jbe/bsw@0
 | 
   882         LUA_REGISTRYINDEX,
 | 
| 
jbe/bsw@0
 | 
   883         MONDELEFANT_ERROROBJECT_MT_REGKEY
 | 
| 
jbe/bsw@0
 | 
   884       );
 | 
| 
jbe/bsw@0
 | 
   885       lua_setmetatable(L, 5);
 | 
| 
jbe/bsw@0
 | 
   886       lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
   887       lua_setfield(L, 5, "connection");
 | 
| 
jbe/bsw@0
 | 
   888       lua_pushinteger(L, command_idx + 1);
 | 
| 
jbe/bsw@0
 | 
   889       lua_setfield(L, 5, "command_number");
 | 
| 
jbe/bsw@0
 | 
   890       lua_pushvalue(L, 2);
 | 
| 
jbe/bsw@0
 | 
   891       lua_setfield(L, 5, "sql_command");
 | 
| 
jbe/bsw@0
 | 
   892       if (!res) {
 | 
| 
jbe/bsw@0
 | 
   893         lua_pushliteral(L, MONDELEFANT_ERRCODE_RESULTCOUNT_LOW);
 | 
| 
jbe/bsw@0
 | 
   894         lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   895         lua_pushliteral(L, "Received too few database result sets.");
 | 
| 
jbe/bsw@0
 | 
   896         lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   897       } else if (command_idx >= command_count) {
 | 
| 
jbe/bsw@0
 | 
   898         lua_pushliteral(L, MONDELEFANT_ERRCODE_RESULTCOUNT_HIGH);
 | 
| 
jbe/bsw@0
 | 
   899         lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   900         lua_pushliteral(L, "Received too many database result sets.");
 | 
| 
jbe/bsw@0
 | 
   901         lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   902       } else if (
 | 
| 
jbe/bsw@0
 | 
   903         pgstatus != PGRES_TUPLES_OK && pgstatus != PGRES_COMMAND_OK
 | 
| 
jbe/bsw@0
 | 
   904       ) {
 | 
| 
jbe/bsw@0
 | 
   905         const char *sqlstate;
 | 
| 
jbe/bsw@0
 | 
   906         const char *errmsg;
 | 
| 
jbe/bsw@0
 | 
   907         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_SEVERITY));
 | 
| 
jbe/bsw@0
 | 
   908         lua_setfield(L, 5, "pg_severity");
 | 
| 
jbe/bsw@0
 | 
   909         sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
 | 
| 
jbe/bsw@0
 | 
   910         if (sqlstate) {
 | 
| 
jbe/bsw@0
 | 
   911           lua_pushstring(L, sqlstate);
 | 
| 
jbe/bsw@0
 | 
   912           lua_setfield(L, 5, "pg_sqlstate");
 | 
| 
jbe/bsw@0
 | 
   913           lua_pushstring(L, mondelefant_translate_errcode(sqlstate));
 | 
| 
jbe/bsw@0
 | 
   914           lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   915         } else {
 | 
| 
jbe/bsw@0
 | 
   916           lua_pushliteral(L, MONDELEFANT_ERRCODE_UNKNOWN);
 | 
| 
jbe/bsw@0
 | 
   917           lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   918         }
 | 
| 
jbe/bsw@0
 | 
   919         errmsg = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
 | 
| 
jbe/bsw@0
 | 
   920         if (errmsg) {
 | 
| 
jbe/bsw@0
 | 
   921           mondelefant_push_first_line(L, errmsg);
 | 
| 
jbe/bsw@0
 | 
   922           lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   923           lua_pushstring(L, errmsg);
 | 
| 
jbe/bsw@0
 | 
   924           lua_setfield(L, 5, "pg_message_primary");
 | 
| 
jbe/bsw@0
 | 
   925         } else {
 | 
| 
jbe/bsw@0
 | 
   926           lua_pushliteral(L,
 | 
| 
jbe/bsw@0
 | 
   927             "Error while fetching result, but no error message given."
 | 
| 
jbe/bsw@0
 | 
   928           );
 | 
| 
jbe/bsw@0
 | 
   929           lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   930         }
 | 
| 
jbe/bsw@0
 | 
   931         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL));
 | 
| 
jbe/bsw@0
 | 
   932         lua_setfield(L, 5, "pg_message_detail");
 | 
| 
jbe/bsw@0
 | 
   933         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_MESSAGE_HINT));
 | 
| 
jbe/bsw@0
 | 
   934         lua_setfield(L, 5, "pg_message_hint");
 | 
| 
jbe/bsw@0
 | 
   935         // NOTE: "position" and "pg_internal_position" are recalculated to
 | 
| 
jbe/bsw@0
 | 
   936         // byte offsets, as Lua 5.1 is not Unicode aware.
 | 
| 
jbe/bsw@0
 | 
   937         {
 | 
| 
jbe/bsw@0
 | 
   938           char *tmp;
 | 
| 
jbe/bsw@0
 | 
   939           tmp = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
 | 
| 
jbe/bsw@0
 | 
   940           if (tmp) {
 | 
| 
jbe/bsw@0
 | 
   941             int pos;
 | 
| 
jbe/bsw@0
 | 
   942             pos = atoi(tmp) - 1;
 | 
| 
jbe/bsw@0
 | 
   943             if (conn->server_encoding == MONDELEFANT_SERVER_ENCODING_UTF8) {
 | 
| 
jbe/bsw@0
 | 
   944               pos = utf8_position_to_byte(command, pos);
 | 
| 
jbe/bsw@0
 | 
   945             }
 | 
| 
jbe/bsw@0
 | 
   946             lua_pushinteger(L, pos + 1);
 | 
| 
jbe/bsw@0
 | 
   947             lua_setfield(L, 5, "position");
 | 
| 
jbe/bsw@0
 | 
   948           }
 | 
| 
jbe/bsw@0
 | 
   949         }
 | 
| 
jbe/bsw@0
 | 
   950         {
 | 
| 
jbe/bsw@0
 | 
   951           const char *internal_query;
 | 
| 
jbe/bsw@0
 | 
   952           internal_query = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
 | 
| 
jbe/bsw@0
 | 
   953           lua_pushstring(L, internal_query);
 | 
| 
jbe/bsw@0
 | 
   954           lua_setfield(L, 5, "pg_internal_query");
 | 
| 
jbe/bsw@0
 | 
   955           char *tmp;
 | 
| 
jbe/bsw@0
 | 
   956           tmp = PQresultErrorField(res, PG_DIAG_INTERNAL_POSITION);
 | 
| 
jbe/bsw@0
 | 
   957           if (tmp) {
 | 
| 
jbe/bsw@0
 | 
   958             int pos;
 | 
| 
jbe/bsw@0
 | 
   959             pos = atoi(tmp) - 1;
 | 
| 
jbe/bsw@0
 | 
   960             if (conn->server_encoding == MONDELEFANT_SERVER_ENCODING_UTF8) {
 | 
| 
jbe/bsw@0
 | 
   961               pos = utf8_position_to_byte(internal_query, pos);
 | 
| 
jbe/bsw@0
 | 
   962             }
 | 
| 
jbe/bsw@0
 | 
   963             lua_pushinteger(L, pos + 1);
 | 
| 
jbe/bsw@0
 | 
   964             lua_setfield(L, 5, "pg_internal_position");
 | 
| 
jbe/bsw@0
 | 
   965           }
 | 
| 
jbe/bsw@0
 | 
   966         }
 | 
| 
jbe/bsw@0
 | 
   967         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_CONTEXT));
 | 
| 
jbe/bsw@0
 | 
   968         lua_setfield(L, 5, "pg_context");
 | 
| 
jbe/bsw@0
 | 
   969         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_SOURCE_FILE));
 | 
| 
jbe/bsw@0
 | 
   970         lua_setfield(L, 5, "pg_source_file");
 | 
| 
jbe/bsw@0
 | 
   971         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_SOURCE_LINE));
 | 
| 
jbe/bsw@0
 | 
   972         lua_setfield(L, 5, "pg_source_line");
 | 
| 
jbe/bsw@0
 | 
   973         lua_pushstring(L, PQresultErrorField(res, PG_DIAG_SOURCE_FUNCTION));
 | 
| 
jbe/bsw@0
 | 
   974         lua_setfield(L, 5, "pg_source_function");
 | 
| 
jbe/bsw@0
 | 
   975       } else if (rows < 1 && mode == MONDELEFANT_QUERY_MODE_OBJECT) {
 | 
| 
jbe/bsw@0
 | 
   976         lua_pushliteral(L, MONDELEFANT_ERRCODE_QUERY1_NO_ROWS);
 | 
| 
jbe/bsw@0
 | 
   977         lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   978         lua_pushliteral(L, "Expected one row, but got empty set.");
 | 
| 
jbe/bsw@0
 | 
   979         lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   980       } else if (rows > 1 && mode != MONDELEFANT_QUERY_MODE_LIST) {
 | 
| 
jbe/bsw@0
 | 
   981         lua_pushliteral(L, MONDELEFANT_ERRCODE_QUERY1_MULTIPLE_ROWS);
 | 
| 
jbe/bsw@0
 | 
   982         lua_setfield(L, 5, "code");
 | 
| 
jbe/bsw@0
 | 
   983         lua_pushliteral(L, "Got more than one result row.");
 | 
| 
jbe/bsw@0
 | 
   984         lua_setfield(L, 5, "message");
 | 
| 
jbe/bsw@0
 | 
   985       } else {
 | 
| 
jbe/bsw@0
 | 
   986         // should not happen
 | 
| 
jbe/bsw@0
 | 
   987         abort();
 | 
| 
jbe/bsw@0
 | 
   988       }
 | 
| 
jbe/bsw@0
 | 
   989       if (res) {
 | 
| 
jbe/bsw@0
 | 
   990         PQclear(res);
 | 
| 
jbe/bsw@0
 | 
   991         while ((res = PQgetResult(conn->pgconn))) PQclear(res);
 | 
| 
jbe/bsw@0
 | 
   992       }
 | 
| 
jbe/bsw@0
 | 
   993       if (lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
   994         lua_pushvalue(L, 3);
 | 
| 
jbe/bsw@0
 | 
   995         lua_pushvalue(L, 5);
 | 
| 
jbe/bsw@0
 | 
   996         lua_call(L, 1, 0);
 | 
| 
jbe/bsw@0
 | 
   997       }
 | 
| 
jbe/bsw@0
 | 
   998       return 1;
 | 
| 
jbe/bsw@0
 | 
   999     }
 | 
| 
jbe@23
 | 
  1000     // call "create_list" or "create_object" method of database handle,
 | 
| 
jbe@23
 | 
  1001     // result will be at stack position 5:
 | 
| 
jbe/bsw@0
 | 
  1002     if (modes[command_idx] == MONDELEFANT_QUERY_MODE_LIST) {
 | 
| 
jbe/bsw@0
 | 
  1003       lua_pushcfunction(L, mondelefant_conn_create_list);  // 5
 | 
| 
jbe/bsw@0
 | 
  1004       lua_pushvalue(L, 1);  // 6
 | 
| 
jbe/bsw@0
 | 
  1005       lua_call(L, 1, 1);  // 5
 | 
| 
jbe/bsw@0
 | 
  1006     } else {
 | 
| 
jbe/bsw@0
 | 
  1007       lua_pushcfunction(L, mondelefant_conn_create_object);  // 5
 | 
| 
jbe/bsw@0
 | 
  1008       lua_pushvalue(L, 1);  // 6
 | 
| 
jbe/bsw@0
 | 
  1009       lua_call(L, 1, 1);  // 5
 | 
| 
jbe/bsw@0
 | 
  1010     }
 | 
| 
jbe@23
 | 
  1011     // set "_column_info":
 | 
| 
jbe@23
 | 
  1012     lua_newtable(L);  // 6
 | 
| 
jbe/bsw@0
 | 
  1013     for (col = 0; col < cols; col++) {
 | 
| 
jbe/bsw@0
 | 
  1014       lua_newtable(L);  // 7
 | 
| 
jbe/bsw@0
 | 
  1015       lua_pushstring(L, PQfname(res, col));
 | 
| 
jbe/bsw@0
 | 
  1016       lua_setfield(L, 7, "field_name");
 | 
| 
jbe/bsw@0
 | 
  1017       {
 | 
| 
jbe/bsw@0
 | 
  1018         Oid tmp;
 | 
| 
jbe/bsw@0
 | 
  1019         tmp = PQftable(res, col);
 | 
| 
jbe/bsw@0
 | 
  1020         if (tmp == InvalidOid) lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1021         else lua_pushinteger(L, tmp);
 | 
| 
jbe/bsw@0
 | 
  1022         lua_setfield(L, 7, "table_oid");
 | 
| 
jbe/bsw@0
 | 
  1023       }
 | 
| 
jbe/bsw@0
 | 
  1024       {
 | 
| 
jbe/bsw@0
 | 
  1025         int tmp;
 | 
| 
jbe/bsw@0
 | 
  1026         tmp = PQftablecol(res, col);
 | 
| 
jbe/bsw@0
 | 
  1027         if (tmp == 0) lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1028         else lua_pushinteger(L, tmp);
 | 
| 
jbe/bsw@0
 | 
  1029         lua_setfield(L, 7, "table_column_number");
 | 
| 
jbe/bsw@0
 | 
  1030       }
 | 
| 
jbe/bsw@0
 | 
  1031       {
 | 
| 
jbe/bsw@0
 | 
  1032         Oid tmp;
 | 
| 
jbe/bsw@0
 | 
  1033         tmp = PQftype(res, col);
 | 
| 
jbe/bsw@0
 | 
  1034         binary[col] = (tmp == MONDELEFANT_POSTGRESQL_BINARY_OID);
 | 
| 
jbe/bsw@0
 | 
  1035         lua_pushinteger(L, tmp);
 | 
| 
jbe/bsw@0
 | 
  1036         lua_setfield(L, 7, "type_oid");
 | 
| 
jbe/bsw@0
 | 
  1037         lua_pushstring(L, mondelefant_oid_to_typestr(tmp));
 | 
| 
jbe/bsw@0
 | 
  1038         lua_setfield(L, 7, "type");
 | 
| 
jbe/bsw@0
 | 
  1039       }
 | 
| 
jbe/bsw@0
 | 
  1040       {
 | 
| 
jbe/bsw@0
 | 
  1041         int tmp;
 | 
| 
jbe/bsw@0
 | 
  1042         tmp = PQfmod(res, col);
 | 
| 
jbe/bsw@0
 | 
  1043         if (tmp == -1) lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1044         else lua_pushinteger(L, tmp);
 | 
| 
jbe/bsw@0
 | 
  1045         lua_setfield(L, 7, "type_modifier");
 | 
| 
jbe/bsw@0
 | 
  1046       }
 | 
| 
jbe/bsw@0
 | 
  1047       lua_rawseti(L, 6, col+1);
 | 
| 
jbe/bsw@0
 | 
  1048     }
 | 
| 
jbe@23
 | 
  1049     lua_setfield(L, 5, "_column_info");
 | 
| 
jbe@23
 | 
  1050     // set "_rows_affected":
 | 
| 
jbe/bsw@0
 | 
  1051     {
 | 
| 
jbe/bsw@0
 | 
  1052       char *tmp;
 | 
| 
jbe/bsw@0
 | 
  1053       tmp = PQcmdTuples(res);
 | 
| 
jbe/bsw@0
 | 
  1054       if (tmp[0]) {
 | 
| 
jbe/bsw@0
 | 
  1055         lua_pushinteger(L, atoi(tmp));
 | 
| 
jbe/bsw@0
 | 
  1056         lua_setfield(L, 5, "_rows_affected");
 | 
| 
jbe/bsw@0
 | 
  1057       }
 | 
| 
jbe/bsw@0
 | 
  1058     }
 | 
| 
jbe@23
 | 
  1059     // set "_oid":
 | 
| 
jbe/bsw@0
 | 
  1060     {
 | 
| 
jbe/bsw@0
 | 
  1061       Oid tmp;
 | 
| 
jbe/bsw@0
 | 
  1062       tmp = PQoidValue(res);
 | 
| 
jbe/bsw@0
 | 
  1063       if (tmp != InvalidOid) {
 | 
| 
jbe/bsw@0
 | 
  1064         lua_pushinteger(L, tmp);
 | 
| 
jbe/bsw@0
 | 
  1065         lua_setfield(L, 5, "_oid");
 | 
| 
jbe/bsw@0
 | 
  1066       }
 | 
| 
jbe/bsw@0
 | 
  1067     }
 | 
| 
jbe@23
 | 
  1068     // copy data as strings or nil, while performing binary unescaping
 | 
| 
jbe@23
 | 
  1069     // automatically:
 | 
| 
jbe/bsw@0
 | 
  1070     if (modes[command_idx] == MONDELEFANT_QUERY_MODE_LIST) {
 | 
| 
jbe/bsw@0
 | 
  1071       for (row = 0; row < rows; row++) {
 | 
| 
jbe/bsw@0
 | 
  1072         lua_pushcfunction(L, mondelefant_conn_create_object);  // 6
 | 
| 
jbe/bsw@0
 | 
  1073         lua_pushvalue(L, 1);  // 7
 | 
| 
jbe/bsw@0
 | 
  1074         lua_call(L, 1, 1);  // 6
 | 
| 
jbe/bsw@0
 | 
  1075         for (col = 0; col < cols; col++) {
 | 
| 
jbe/bsw@0
 | 
  1076           if (PQgetisnull(res, row, col)) {
 | 
| 
jbe/bsw@0
 | 
  1077             lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1078           } else if (binary[col]) {
 | 
| 
jbe/bsw@0
 | 
  1079             size_t binlen;
 | 
| 
jbe/bsw@0
 | 
  1080             char *binval;
 | 
| 
jbe/bsw@0
 | 
  1081             binval = (char *)PQunescapeBytea(
 | 
| 
jbe/bsw@0
 | 
  1082               (unsigned char *)PQgetvalue(res, row, col), &binlen
 | 
| 
jbe/bsw@0
 | 
  1083             );
 | 
| 
jbe/bsw@0
 | 
  1084             if (!binval) {
 | 
| 
jbe/bsw@0
 | 
  1085               return luaL_error(L,
 | 
| 
jbe/bsw@0
 | 
  1086                 "Could not allocate memory for binary unescaping."
 | 
| 
jbe/bsw@0
 | 
  1087               );
 | 
| 
jbe/bsw@0
 | 
  1088             }
 | 
| 
jbe/bsw@0
 | 
  1089             lua_pushlstring(L, binval, binlen);
 | 
| 
jbe/bsw@0
 | 
  1090             PQfreemem(binval);
 | 
| 
jbe/bsw@0
 | 
  1091           } else {
 | 
| 
jbe/bsw@0
 | 
  1092             lua_pushstring(L, PQgetvalue(res, row, col));
 | 
| 
jbe/bsw@0
 | 
  1093           }
 | 
| 
jbe/bsw@0
 | 
  1094           lua_rawseti(L, 6, col+1);
 | 
| 
jbe/bsw@0
 | 
  1095         }
 | 
| 
jbe/bsw@0
 | 
  1096         lua_rawseti(L, 5, row+1);
 | 
| 
jbe/bsw@0
 | 
  1097       }
 | 
| 
jbe/bsw@0
 | 
  1098     } else if (rows == 1) {
 | 
| 
jbe/bsw@0
 | 
  1099       for (col = 0; col < cols; col++) {
 | 
| 
jbe/bsw@0
 | 
  1100         if (PQgetisnull(res, 0, col)) {
 | 
| 
jbe/bsw@0
 | 
  1101           lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1102         } else if (binary[col]) {
 | 
| 
jbe/bsw@0
 | 
  1103           size_t binlen;
 | 
| 
jbe/bsw@0
 | 
  1104           char *binval;
 | 
| 
jbe/bsw@0
 | 
  1105           binval = (char *)PQunescapeBytea(
 | 
| 
jbe/bsw@0
 | 
  1106             (unsigned char *)PQgetvalue(res, 0, col), &binlen
 | 
| 
jbe/bsw@0
 | 
  1107           );
 | 
| 
jbe/bsw@0
 | 
  1108           if (!binval) {
 | 
| 
jbe/bsw@0
 | 
  1109             return luaL_error(L,
 | 
| 
jbe/bsw@0
 | 
  1110               "Could not allocate memory for binary unescaping."
 | 
| 
jbe/bsw@0
 | 
  1111             );
 | 
| 
jbe/bsw@0
 | 
  1112           }
 | 
| 
jbe/bsw@0
 | 
  1113           lua_pushlstring(L, binval, binlen);
 | 
| 
jbe/bsw@0
 | 
  1114           PQfreemem(binval);
 | 
| 
jbe/bsw@0
 | 
  1115         } else {
 | 
| 
jbe/bsw@0
 | 
  1116           lua_pushstring(L, PQgetvalue(res, 0, col));
 | 
| 
jbe/bsw@0
 | 
  1117         }
 | 
| 
jbe/bsw@0
 | 
  1118         lua_rawseti(L, 5, col+1);
 | 
| 
jbe/bsw@0
 | 
  1119       }
 | 
| 
jbe/bsw@0
 | 
  1120     } else {
 | 
| 
jbe/bsw@0
 | 
  1121       // no row in optrow mode
 | 
| 
jbe/bsw@0
 | 
  1122       lua_pop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1123       lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1124     }
 | 
| 
jbe@23
 | 
  1125     // save result in result list:
 | 
| 
jbe/bsw@0
 | 
  1126     lua_rawseti(L, 4, command_idx+1);
 | 
| 
jbe@23
 | 
  1127     // extra assertion:
 | 
| 
jbe/bsw@0
 | 
  1128     if (lua_gettop(L) != 4) abort();  // should not happen
 | 
| 
jbe@23
 | 
  1129     // free memory acquired by libpq:
 | 
| 
jbe/bsw@0
 | 
  1130     PQclear(res);
 | 
| 
jbe/bsw@0
 | 
  1131   }
 | 
| 
jbe/bsw@0
 | 
  1132   // trace callback at stack position 3
 | 
| 
jbe/bsw@0
 | 
  1133   // result at stack position 4 (top of stack)
 | 
| 
jbe@23
 | 
  1134   // if a trace callback is existent, then call:
 | 
| 
jbe/bsw@0
 | 
  1135   if (lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1136     lua_pushvalue(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1137     lua_call(L, 0, 0);
 | 
| 
jbe/bsw@0
 | 
  1138   }
 | 
| 
jbe@23
 | 
  1139   // put result at stack position 3:
 | 
| 
jbe@23
 | 
  1140   lua_replace(L, 3);
 | 
| 
jbe@23
 | 
  1141   // get output converter to stack position 4:
 | 
| 
jbe@23
 | 
  1142   lua_getfield(L, 1, "output_converter");
 | 
| 
jbe@23
 | 
  1143   // apply output converters and fill "_data" table according to column names:
 | 
| 
jbe/bsw@0
 | 
  1144   for (command_idx = 0; command_idx < command_count; command_idx++) {
 | 
| 
jbe/bsw@0
 | 
  1145     int mode;
 | 
| 
jbe/bsw@0
 | 
  1146     mode = modes[command_idx];
 | 
| 
jbe/bsw@0
 | 
  1147     lua_rawgeti(L, 3, command_idx+1);  // raw result at stack position 5
 | 
| 
jbe/bsw@0
 | 
  1148     if (lua_toboolean(L, 5)) {
 | 
| 
jbe/bsw@0
 | 
  1149       lua_getfield(L, 5, "_column_info");  // column_info list at position 6
 | 
| 
jbe@64
 | 
  1150 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1151       cols = lua_rawlen(L, 6);
 | 
| 
jbe@64
 | 
  1152 #else
 | 
| 
jbe/bsw@0
 | 
  1153       cols = lua_objlen(L, 6);
 | 
| 
jbe@64
 | 
  1154 #endif
 | 
| 
jbe/bsw@0
 | 
  1155       if (mode == MONDELEFANT_QUERY_MODE_LIST) {
 | 
| 
jbe@64
 | 
  1156 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1157         rows = lua_rawlen(L, 5);
 | 
| 
jbe@64
 | 
  1158 #else
 | 
| 
jbe/bsw@0
 | 
  1159         rows = lua_objlen(L, 5);
 | 
| 
jbe@64
 | 
  1160 #endif
 | 
| 
jbe/bsw@0
 | 
  1161         for (row = 0; row < rows; row++) {
 | 
| 
jbe/bsw@0
 | 
  1162           lua_rawgeti(L, 5, row+1);  // row at stack position 7
 | 
| 
jbe/bsw@0
 | 
  1163           lua_getfield(L, 7, "_data");  // _data table at stack position 8
 | 
| 
jbe/bsw@0
 | 
  1164           for (col = 0; col < cols; col++) {
 | 
| 
jbe/bsw@0
 | 
  1165             lua_rawgeti(L, 6, col+1);  // this column info at position 9
 | 
| 
jbe/bsw@0
 | 
  1166             lua_getfield(L, 9, "field_name");  // 10
 | 
| 
jbe/bsw@0
 | 
  1167             if (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1168               lua_pushvalue(L, 4);  // output-converter
 | 
| 
jbe/bsw@0
 | 
  1169               lua_pushvalue(L, 1);  // connection
 | 
| 
jbe/bsw@0
 | 
  1170               lua_rawgeti(L, 7, col+1);  // raw-value
 | 
| 
jbe/bsw@0
 | 
  1171               lua_pushvalue(L, 9);  // this column info
 | 
| 
jbe/bsw@0
 | 
  1172               lua_call(L, 3, 1);  // converted value at position 11
 | 
| 
jbe/bsw@0
 | 
  1173             } else {
 | 
| 
jbe/bsw@0
 | 
  1174               lua_rawgeti(L, 7, col+1);  // raw-value at position 11
 | 
| 
jbe/bsw@0
 | 
  1175             }
 | 
| 
jbe/bsw@0
 | 
  1176             lua_pushvalue(L, 11);  // 12
 | 
| 
jbe/bsw@0
 | 
  1177             lua_rawseti(L, 7, col+1);
 | 
| 
jbe/bsw@0
 | 
  1178             lua_rawset(L, 8);
 | 
| 
jbe/bsw@0
 | 
  1179             lua_settop(L, 8);
 | 
| 
jbe/bsw@0
 | 
  1180           }
 | 
| 
jbe/bsw@0
 | 
  1181           lua_settop(L, 6);
 | 
| 
jbe/bsw@0
 | 
  1182         }
 | 
| 
jbe/bsw@0
 | 
  1183       } else {
 | 
| 
jbe/bsw@0
 | 
  1184         lua_getfield(L, 5, "_data");  // _data table at stack position 7
 | 
| 
jbe/bsw@0
 | 
  1185         for (col = 0; col < cols; col++) {
 | 
| 
jbe/bsw@0
 | 
  1186           lua_rawgeti(L, 6, col+1);  // this column info at position 8
 | 
| 
jbe/bsw@0
 | 
  1187           lua_getfield(L, 8, "field_name");  // 9
 | 
| 
jbe/bsw@0
 | 
  1188           if (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1189             lua_pushvalue(L, 4);  // output-converter
 | 
| 
jbe/bsw@0
 | 
  1190             lua_pushvalue(L, 1);  // connection
 | 
| 
jbe/bsw@0
 | 
  1191             lua_rawgeti(L, 5, col+1);  // raw-value
 | 
| 
jbe/bsw@0
 | 
  1192             lua_pushvalue(L, 8);  // this column info
 | 
| 
jbe/bsw@0
 | 
  1193             lua_call(L, 3, 1);  // converted value at position 10
 | 
| 
jbe/bsw@0
 | 
  1194           } else {
 | 
| 
jbe/bsw@0
 | 
  1195             lua_rawgeti(L, 5, col+1);  // raw-value at position 10
 | 
| 
jbe/bsw@0
 | 
  1196           }
 | 
| 
jbe/bsw@0
 | 
  1197           lua_pushvalue(L, 10);  // 11
 | 
| 
jbe/bsw@0
 | 
  1198           lua_rawseti(L, 5, col+1);
 | 
| 
jbe/bsw@0
 | 
  1199           lua_rawset(L, 7);
 | 
| 
jbe/bsw@0
 | 
  1200           lua_settop(L, 7);
 | 
| 
jbe/bsw@0
 | 
  1201         }
 | 
| 
jbe/bsw@0
 | 
  1202       }
 | 
| 
jbe/bsw@0
 | 
  1203     }
 | 
| 
jbe/bsw@0
 | 
  1204     lua_settop(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1205   }
 | 
| 
jbe@23
 | 
  1206   // return nil as first result value, followed by result lists/objects:
 | 
| 
jbe/bsw@0
 | 
  1207   lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1208   lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1209   for (command_idx = 0; command_idx < command_count; command_idx++) {
 | 
| 
jbe/bsw@0
 | 
  1210     lua_rawgeti(L, 3, command_idx+1);
 | 
| 
jbe/bsw@0
 | 
  1211   }
 | 
| 
jbe/bsw@0
 | 
  1212   return command_count+1;
 | 
| 
jbe/bsw@0
 | 
  1213 }
 | 
| 
jbe/bsw@0
 | 
  1214 
 | 
| 
jbe@23
 | 
  1215 // method "escalate" of error objects:
 | 
| 
jbe/bsw@0
 | 
  1216 static int mondelefant_errorobject_escalate(lua_State *L) {
 | 
| 
jbe@23
 | 
  1217   // check, if we may throw an error object instead of an error string:
 | 
| 
jbe/bsw@0
 | 
  1218   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1219   lua_getfield(L, 1, "connection");  // 2
 | 
| 
jbe/bsw@0
 | 
  1220   lua_getfield(L, 2, "error_objects");  // 3
 | 
| 
jbe/bsw@0
 | 
  1221   if (lua_toboolean(L, 3)) {
 | 
| 
jbe@23
 | 
  1222     // throw error object:
 | 
| 
jbe/bsw@0
 | 
  1223     lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1224     return lua_error(L);
 | 
| 
jbe/bsw@0
 | 
  1225   } else {
 | 
| 
jbe@23
 | 
  1226     // throw error string:
 | 
| 
jbe/bsw@0
 | 
  1227     lua_getfield(L, 1, "message");  // 4
 | 
| 
jbe/bsw@0
 | 
  1228     if (lua_isnil(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1229       return luaL_error(L, "No error message given for escalation.");
 | 
| 
jbe/bsw@0
 | 
  1230     }
 | 
| 
jbe/bsw@0
 | 
  1231     return lua_error(L);
 | 
| 
jbe/bsw@0
 | 
  1232   }
 | 
| 
jbe/bsw@0
 | 
  1233 }
 | 
| 
jbe/bsw@0
 | 
  1234 
 | 
| 
jbe@23
 | 
  1235 // method "is_kind_of" of error objects:
 | 
| 
jbe/bsw@0
 | 
  1236 static int mondelefant_errorobject_is_kind_of(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1237   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1238   lua_getfield(L, 1, "code");  // 3
 | 
| 
jbe/bsw@0
 | 
  1239   if (lua_isstring(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1240     lua_pushboolean(L,
 | 
| 
jbe/bsw@0
 | 
  1241       mondelefant_check_error_class(
 | 
| 
jbe/bsw@0
 | 
  1242         lua_tostring(L, 3), luaL_checkstring(L, 2)
 | 
| 
jbe/bsw@0
 | 
  1243       )
 | 
| 
jbe/bsw@0
 | 
  1244     );
 | 
| 
jbe/bsw@0
 | 
  1245   } else {
 | 
| 
jbe/bsw@0
 | 
  1246     // only happens for errors where code is not set
 | 
| 
jbe/bsw@0
 | 
  1247     lua_pushboolean(L, 0);
 | 
| 
jbe/bsw@0
 | 
  1248   }
 | 
| 
jbe/bsw@0
 | 
  1249   return 1;
 | 
| 
jbe/bsw@0
 | 
  1250 }
 | 
| 
jbe/bsw@0
 | 
  1251 
 | 
| 
jbe@23
 | 
  1252 // method "query" of database handles:
 | 
| 
jbe/bsw@0
 | 
  1253 static int mondelefant_conn_query(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1254   int argc;
 | 
| 
jbe@23
 | 
  1255   // count number of arguments:
 | 
| 
jbe/bsw@0
 | 
  1256   argc = lua_gettop(L);
 | 
| 
jbe@23
 | 
  1257   // insert "try_query" function/method at stack position 1:
 | 
| 
jbe/bsw@0
 | 
  1258   lua_pushcfunction(L, mondelefant_conn_try_query);
 | 
| 
jbe@23
 | 
  1259   lua_insert(L, 1);
 | 
| 
jbe@23
 | 
  1260   // call "try_query" method:
 | 
| 
jbe@23
 | 
  1261   lua_call(L, argc, LUA_MULTRET);  // results (with error) starting at index 1
 | 
| 
jbe@23
 | 
  1262   // check, if error occurred:
 | 
| 
jbe@23
 | 
  1263   if (lua_toboolean(L, 1)) {
 | 
| 
jbe@23
 | 
  1264     // invoke escalate method of error object:
 | 
| 
jbe/bsw@0
 | 
  1265     lua_pushcfunction(L, mondelefant_errorobject_escalate);
 | 
| 
jbe@23
 | 
  1266     lua_pushvalue(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1267     lua_call(L, 1, 0);  // will raise an error
 | 
| 
jbe/bsw@0
 | 
  1268     return 0;  // should not be executed
 | 
| 
jbe/bsw@0
 | 
  1269   } else {
 | 
| 
jbe@23
 | 
  1270     // return everything but nil error object:
 | 
| 
jbe@23
 | 
  1271     return lua_gettop(L) - 1;
 | 
| 
jbe/bsw@0
 | 
  1272   }
 | 
| 
jbe/bsw@0
 | 
  1273 }
 | 
| 
jbe/bsw@0
 | 
  1274 
 | 
| 
jbe@23
 | 
  1275 // library function "set_class":
 | 
| 
jbe/bsw@0
 | 
  1276 static int mondelefant_set_class(lua_State *L) {
 | 
| 
jbe@23
 | 
  1277   // ensure that first argument is a database result list/object:
 | 
| 
jbe/bsw@0
 | 
  1278   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1279   lua_getmetatable(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1280   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_RESULT_MT_REGKEY);  // 4
 | 
| 
jbe@64
 | 
  1281 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1282   luaL_argcheck(L, lua_compare(L, 3, 4, LUA_OPEQ), 1, "not a database result");
 | 
| 
jbe@64
 | 
  1283 #else
 | 
| 
jbe/bsw@0
 | 
  1284   luaL_argcheck(L, lua_equal(L, 3, 4), 1, "not a database result");
 | 
| 
jbe@64
 | 
  1285 #endif
 | 
| 
jbe@23
 | 
  1286   // ensure that second argument is a database class (model):
 | 
| 
jbe/bsw@0
 | 
  1287   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1288   lua_getmetatable(L, 2);  // 3
 | 
| 
jbe/bsw@0
 | 
  1289   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CLASS_MT_REGKEY);  // 4
 | 
| 
jbe@64
 | 
  1290 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1291   luaL_argcheck(L, lua_compare(L, 3, 4, LUA_OPEQ), 2, "not a database class");
 | 
| 
jbe@64
 | 
  1292 #else
 | 
| 
jbe/bsw@0
 | 
  1293   luaL_argcheck(L, lua_equal(L, 3, 4), 2, "not a database class");
 | 
| 
jbe@64
 | 
  1294 #endif
 | 
| 
jbe@23
 | 
  1295   // set attribute "_class" of result list/object to given class:
 | 
| 
jbe/bsw@0
 | 
  1296   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1297   lua_pushvalue(L, 2);  // 3
 | 
| 
jbe/bsw@0
 | 
  1298   lua_setfield(L, 1, "_class");
 | 
| 
jbe@23
 | 
  1299   // test, if database result is a list (and not a single object):
 | 
| 
jbe/bsw@0
 | 
  1300   lua_getfield(L, 1, "_type");  // 3
 | 
| 
jbe/bsw@0
 | 
  1301   lua_pushliteral(L, "list");  // 4
 | 
| 
jbe/bsw@0
 | 
  1302   if (lua_rawequal(L, 3, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1303     int i;
 | 
| 
jbe@23
 | 
  1304     // set attribute "_class" of all elements to given class:
 | 
| 
jbe@64
 | 
  1305 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1306     for (i=0; i < lua_rawlen(L, 1); i++) {
 | 
| 
jbe@64
 | 
  1307 #else
 | 
| 
jbe/bsw@0
 | 
  1308     for (i=0; i < lua_objlen(L, 1); i++) {
 | 
| 
jbe@64
 | 
  1309 #endif
 | 
| 
jbe/bsw@0
 | 
  1310       lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1311       lua_rawgeti(L, 1, i+1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1312       lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1313       lua_setfield(L, 3, "_class");
 | 
| 
jbe/bsw@0
 | 
  1314     }
 | 
| 
jbe/bsw@0
 | 
  1315   }
 | 
| 
jbe@23
 | 
  1316   // return first argument:
 | 
| 
jbe/bsw@0
 | 
  1317   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1318   return 1;
 | 
| 
jbe/bsw@0
 | 
  1319 }
 | 
| 
jbe/bsw@0
 | 
  1320 
 | 
| 
jbe@23
 | 
  1321 // library function "new_class":
 | 
| 
jbe/bsw@0
 | 
  1322 static int mondelefant_new_class(lua_State *L) {
 | 
| 
jbe@23
 | 
  1323   // use first argument as template or create new table:
 | 
| 
jbe/bsw@0
 | 
  1324   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1325   if (!lua_toboolean(L, 1)) {
 | 
| 
jbe/bsw@0
 | 
  1326     lua_settop(L, 0);
 | 
| 
jbe/bsw@0
 | 
  1327     lua_newtable(L);  // 1
 | 
| 
jbe/bsw@0
 | 
  1328   }
 | 
| 
jbe@23
 | 
  1329   // set meta-table for database classes (models):
 | 
| 
jbe/bsw@0
 | 
  1330   lua_getfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CLASS_MT_REGKEY);  // 2
 | 
| 
jbe/bsw@0
 | 
  1331   lua_setmetatable(L, 1);
 | 
| 
jbe@23
 | 
  1332   // check, if "prototype" attribute is not set:
 | 
| 
jbe/bsw@0
 | 
  1333   lua_pushliteral(L, "prototype");  // 2
 | 
| 
jbe/bsw@0
 | 
  1334   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1335   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe@23
 | 
  1336     // set "prototype" attribute to default prototype:
 | 
| 
jbe/bsw@0
 | 
  1337     lua_pushliteral(L, "prototype");  // 3
 | 
| 
jbe/bsw@0
 | 
  1338     lua_getfield(L,
 | 
| 
jbe/bsw@0
 | 
  1339       LUA_REGISTRYINDEX,
 | 
| 
jbe/bsw@0
 | 
  1340       MONDELEFANT_CLASS_PROTO_REGKEY
 | 
| 
jbe/bsw@0
 | 
  1341     );  // 4
 | 
| 
jbe/bsw@0
 | 
  1342     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1343   }
 | 
| 
jbe@23
 | 
  1344   // set "object" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1345   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1346   lua_pushliteral(L, "object");  // 2
 | 
| 
jbe/bsw@0
 | 
  1347   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1348   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1349     lua_pushliteral(L, "object");  // 3
 | 
| 
jbe/bsw@0
 | 
  1350     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1351     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1352   }
 | 
| 
jbe@23
 | 
  1353   // set "object_get" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1354   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1355   lua_pushliteral(L, "object_get");  // 2
 | 
| 
jbe/bsw@0
 | 
  1356   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1357   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1358     lua_pushliteral(L, "object_get");  // 3
 | 
| 
jbe/bsw@0
 | 
  1359     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1360     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1361   }
 | 
| 
jbe@23
 | 
  1362   // set "object_set" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1363   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1364   lua_pushliteral(L, "object_set");  // 2
 | 
| 
jbe/bsw@0
 | 
  1365   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1366   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1367     lua_pushliteral(L, "object_set");  // 3
 | 
| 
jbe/bsw@0
 | 
  1368     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1369     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1370   }
 | 
| 
jbe@23
 | 
  1371   // set "list" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1372   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1373   lua_pushliteral(L, "list");  // 2
 | 
| 
jbe/bsw@0
 | 
  1374   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1375   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1376     lua_pushliteral(L, "list");  // 3
 | 
| 
jbe/bsw@0
 | 
  1377     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1378     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1379   }
 | 
| 
jbe@23
 | 
  1380   // set "references" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1381   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1382   lua_pushliteral(L, "references");  // 2
 | 
| 
jbe/bsw@0
 | 
  1383   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1384   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1385     lua_pushliteral(L, "references");  // 3
 | 
| 
jbe/bsw@0
 | 
  1386     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1387     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1388   }
 | 
| 
jbe@23
 | 
  1389   // set "foreign_keys" attribute to empty table, unless it is already set:
 | 
| 
jbe/bsw@0
 | 
  1390   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1391   lua_pushliteral(L, "foreign_keys");  // 2
 | 
| 
jbe/bsw@0
 | 
  1392   lua_rawget(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1393   if (!lua_toboolean(L, 2)) {
 | 
| 
jbe/bsw@0
 | 
  1394     lua_pushliteral(L, "foreign_keys");  // 3
 | 
| 
jbe/bsw@0
 | 
  1395     lua_newtable(L);  // 4
 | 
| 
jbe/bsw@0
 | 
  1396     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1397   }
 | 
| 
jbe@23
 | 
  1398   // return table:
 | 
| 
jbe/bsw@0
 | 
  1399   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1400   return 1;
 | 
| 
jbe/bsw@0
 | 
  1401 }
 | 
| 
jbe/bsw@0
 | 
  1402 
 | 
| 
jbe@23
 | 
  1403 // method "get_reference" of classes (models):
 | 
| 
jbe/bsw@0
 | 
  1404 static int mondelefant_class_get_reference(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1405   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1406   while (lua_toboolean(L, 1)) {
 | 
| 
jbe@23
 | 
  1407     // get "references" table:
 | 
| 
jbe/bsw@0
 | 
  1408     lua_getfield(L, 1, "references");  // 3
 | 
| 
jbe@23
 | 
  1409     // perform lookup:
 | 
| 
jbe/bsw@0
 | 
  1410     lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1411     lua_gettable(L, 3);  // 4
 | 
| 
jbe@23
 | 
  1412     // return result, if lookup was successful:
 | 
| 
jbe/bsw@0
 | 
  1413     if (!lua_isnil(L, 4)) return 1;
 | 
| 
jbe@23
 | 
  1414     // replace current table by its prototype:
 | 
| 
jbe/bsw@0
 | 
  1415     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1416     lua_pushliteral(L, "prototype");  // 3
 | 
| 
jbe/bsw@0
 | 
  1417     lua_rawget(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1418     lua_replace(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1419   }
 | 
| 
jbe@23
 | 
  1420   // return nothing:
 | 
| 
jbe/bsw@0
 | 
  1421   return 0;
 | 
| 
jbe/bsw@0
 | 
  1422 }
 | 
| 
jbe/bsw@0
 | 
  1423 
 | 
| 
jbe@23
 | 
  1424 // method "iterate_over_references" of classes (models):
 | 
| 
jbe/bsw@0
 | 
  1425 static int mondelefant_class_iterate_over_references(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1426   return luaL_error(L, "Reference iterator not implemented yet.");  // TODO
 | 
| 
jbe/bsw@0
 | 
  1427 }
 | 
| 
jbe/bsw@0
 | 
  1428 
 | 
| 
jbe@23
 | 
  1429 // method "get_foreign_key_reference_name" of classes (models):
 | 
| 
jbe/bsw@0
 | 
  1430 static int mondelefant_class_get_foreign_key_reference_name(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1431   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1432   while (lua_toboolean(L, 1)) {
 | 
| 
jbe@23
 | 
  1433     // get "foreign_keys" table:
 | 
| 
jbe/bsw@0
 | 
  1434     lua_getfield(L, 1, "foreign_keys");  // 3
 | 
| 
jbe@23
 | 
  1435     // perform lookup:
 | 
| 
jbe/bsw@0
 | 
  1436     lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1437     lua_gettable(L, 3);  // 4
 | 
| 
jbe@23
 | 
  1438     // return result, if lookup was successful:
 | 
| 
jbe/bsw@0
 | 
  1439     if (!lua_isnil(L, 4)) return 1;
 | 
| 
jbe@23
 | 
  1440     // replace current table by its prototype:
 | 
| 
jbe/bsw@0
 | 
  1441     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1442     lua_pushliteral(L, "prototype");  // 3
 | 
| 
jbe/bsw@0
 | 
  1443     lua_rawget(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1444     lua_replace(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1445   }
 | 
| 
jbe@23
 | 
  1446   // return nothing:
 | 
| 
jbe/bsw@0
 | 
  1447   return 0;
 | 
| 
jbe/bsw@0
 | 
  1448 }
 | 
| 
jbe/bsw@0
 | 
  1449 
 | 
| 
jbe@23
 | 
  1450 // meta-method "__index" of database result lists and objects:
 | 
| 
jbe/bsw@0
 | 
  1451 static int mondelefant_result_index(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1452   const char *result_type;
 | 
| 
jbe@23
 | 
  1453   // only lookup, when key is a string not beginning with an underscore:
 | 
| 
jbe/bsw@0
 | 
  1454   if (lua_type(L, 2) != LUA_TSTRING || lua_tostring(L, 2)[0] == '_') {
 | 
| 
jbe@23
 | 
  1455     return 0;
 | 
| 
jbe/bsw@0
 | 
  1456   }
 | 
| 
jbe@23
 | 
  1457   // get value of "_class" attribute, or default class, when unset:
 | 
| 
jbe@23
 | 
  1458   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1459   lua_getfield(L, 1, "_class");  // 3
 | 
| 
jbe/bsw@0
 | 
  1460   if (!lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1461     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1462     lua_getfield(L,
 | 
| 
jbe/bsw@0
 | 
  1463       LUA_REGISTRYINDEX,
 | 
| 
jbe/bsw@0
 | 
  1464       MONDELEFANT_CLASS_PROTO_REGKEY
 | 
| 
jbe/bsw@0
 | 
  1465     );  // 3
 | 
| 
jbe/bsw@0
 | 
  1466   }
 | 
| 
jbe@23
 | 
  1467   // get value of "_type" attribute:
 | 
| 
jbe/bsw@0
 | 
  1468   lua_getfield(L, 1, "_type");  // 4
 | 
| 
jbe/bsw@0
 | 
  1469   result_type = lua_tostring(L, 4);
 | 
| 
jbe@23
 | 
  1470   // different lookup for lists and objects:
 | 
| 
jbe@23
 | 
  1471   if (result_type && !strcmp(result_type, "object")) {  // object
 | 
| 
jbe/bsw@0
 | 
  1472     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1473     // try inherited attributes, methods or getter functions:
 | 
| 
jbe/bsw@0
 | 
  1474     while (lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1475       lua_getfield(L, 3, "object");  // 4
 | 
| 
jbe/bsw@0
 | 
  1476       lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1477       lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
  1478       if (!lua_isnil(L, 5)) return 1;
 | 
| 
jbe/bsw@0
 | 
  1479       lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1480       lua_getfield(L, 3, "object_get");  // 4
 | 
| 
jbe/bsw@0
 | 
  1481       lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1482       lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
  1483       if (lua_toboolean(L, 5)) {
 | 
| 
jbe/bsw@0
 | 
  1484         lua_pushvalue(L, 1);  // 6
 | 
| 
jbe/bsw@0
 | 
  1485         lua_call(L, 1, 1);  // 5
 | 
| 
jbe/bsw@0
 | 
  1486         return 1;
 | 
| 
jbe/bsw@0
 | 
  1487       }
 | 
| 
jbe/bsw@0
 | 
  1488       lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1489       lua_pushliteral(L, "prototype");  // 4
 | 
| 
jbe/bsw@0
 | 
  1490       lua_rawget(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1491       lua_replace(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1492     }
 | 
| 
jbe/bsw@0
 | 
  1493     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1494     // try primary keys of referenced objects:
 | 
| 
jbe/bsw@0
 | 
  1495     lua_pushcfunction(L,
 | 
| 
jbe/bsw@0
 | 
  1496       mondelefant_class_get_foreign_key_reference_name
 | 
| 
jbe/bsw@0
 | 
  1497     );  // 3
 | 
| 
jbe/bsw@0
 | 
  1498     lua_getfield(L, 1, "_class");  // 4
 | 
| 
jbe/bsw@0
 | 
  1499     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1500     lua_call(L, 2, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1501     if (!lua_isnil(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1502       // reference name at stack position 3
 | 
| 
jbe/bsw@0
 | 
  1503       lua_pushcfunction(L, mondelefant_class_get_reference);  // 4
 | 
| 
jbe/bsw@0
 | 
  1504       lua_getfield(L, 1, "_class");  // 5
 | 
| 
jbe/bsw@0
 | 
  1505       lua_pushvalue(L, 3);  // 6
 | 
| 
jbe/bsw@0
 | 
  1506       lua_call(L, 2, 1);  // reference info at stack position 4
 | 
| 
jbe/bsw@0
 | 
  1507       lua_getfield(L, 1, "_ref");  // 5
 | 
| 
jbe/bsw@0
 | 
  1508       lua_getfield(L, 4, "ref");  // 6
 | 
| 
jbe/bsw@0
 | 
  1509       lua_gettable(L, 5);  // 6
 | 
| 
jbe/bsw@0
 | 
  1510       if (!lua_isnil(L, 6)) {
 | 
| 
jbe/bsw@0
 | 
  1511         if (lua_toboolean(L, 6)) {
 | 
| 
jbe/bsw@0
 | 
  1512           lua_getfield(L, 4, "that_key");  // 7
 | 
| 
jbe/bsw@0
 | 
  1513           if (lua_isnil(L, 7)) {
 | 
| 
jbe/bsw@0
 | 
  1514             return luaL_error(L, "Missing 'that_key' entry in model reference.");
 | 
| 
jbe/bsw@0
 | 
  1515           }
 | 
| 
jbe/bsw@0
 | 
  1516           lua_gettable(L, 6);  // 7
 | 
| 
jbe/bsw@0
 | 
  1517         } else {
 | 
| 
jbe/bsw@0
 | 
  1518           lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1519         }
 | 
| 
jbe/bsw@0
 | 
  1520         return 1;
 | 
| 
jbe/bsw@0
 | 
  1521       }
 | 
| 
jbe/bsw@0
 | 
  1522     }
 | 
| 
jbe/bsw@0
 | 
  1523     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1524     // try normal data field info:
 | 
| 
jbe/bsw@0
 | 
  1525     lua_getfield(L, 1, "_data");  // 3
 | 
| 
jbe/bsw@0
 | 
  1526     lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1527     lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1528     if (!lua_isnil(L, 4)) return 1;
 | 
| 
jbe/bsw@0
 | 
  1529     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1530     // try cached referenced object (or cached NULL reference):
 | 
| 
jbe/bsw@0
 | 
  1531     lua_getfield(L, 1, "_ref");  // 3
 | 
| 
jbe/bsw@0
 | 
  1532     lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1533     lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1534     if (lua_isboolean(L, 4) && !lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1535       lua_pushnil(L);
 | 
| 
jbe/bsw@0
 | 
  1536       return 1;
 | 
| 
jbe/bsw@0
 | 
  1537     } else if (!lua_isnil(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1538       return 1;
 | 
| 
jbe/bsw@0
 | 
  1539     }
 | 
| 
jbe/bsw@0
 | 
  1540     lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1541     // try to load a referenced object:
 | 
| 
jbe/bsw@0
 | 
  1542     lua_pushcfunction(L, mondelefant_class_get_reference);  // 3
 | 
| 
jbe/bsw@0
 | 
  1543     lua_getfield(L, 1, "_class");  // 4
 | 
| 
jbe/bsw@0
 | 
  1544     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1545     lua_call(L, 2, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1546     if (!lua_isnil(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1547       lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1548       lua_getfield(L, 1, "load");  // 3
 | 
| 
jbe/bsw@0
 | 
  1549       lua_pushvalue(L, 1);  // 4 (self)
 | 
| 
jbe/bsw@0
 | 
  1550       lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1551       lua_call(L, 2, 0);
 | 
| 
jbe/bsw@0
 | 
  1552       lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1553       lua_getfield(L, 1, "_ref");  // 3
 | 
| 
jbe/bsw@0
 | 
  1554       lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1555       lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1556       if (lua_isboolean(L, 4) && !lua_toboolean(L, 4)) lua_pushnil(L);  // TODO: use special object instead of false
 | 
| 
jbe/bsw@0
 | 
  1557       return 1;
 | 
| 
jbe/bsw@0
 | 
  1558     }
 | 
| 
jbe/bsw@0
 | 
  1559     return 0;
 | 
| 
jbe@23
 | 
  1560   } else if (result_type && !strcmp(result_type, "list")) {  // list
 | 
| 
jbe/bsw@0
 | 
  1561     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1562     // try inherited list attributes or methods:
 | 
| 
jbe/bsw@0
 | 
  1563     while (lua_toboolean(L, 3)) {
 | 
| 
jbe/bsw@0
 | 
  1564       lua_getfield(L, 3, "list");  // 4
 | 
| 
jbe/bsw@0
 | 
  1565       lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1566       lua_gettable(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
  1567       if (!lua_isnil(L, 5)) return 1;
 | 
| 
jbe/bsw@0
 | 
  1568       lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1569       lua_pushliteral(L, "prototype");  // 4
 | 
| 
jbe/bsw@0
 | 
  1570       lua_rawget(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1571       lua_replace(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1572     }
 | 
| 
jbe/bsw@0
 | 
  1573   }
 | 
| 
jbe@23
 | 
  1574   // return nothing:
 | 
| 
jbe/bsw@0
 | 
  1575   return 0;
 | 
| 
jbe/bsw@0
 | 
  1576 }
 | 
| 
jbe/bsw@0
 | 
  1577 
 | 
| 
jbe@23
 | 
  1578 // meta-method "__newindex" of database result lists and objects:
 | 
| 
jbe/bsw@0
 | 
  1579 static int mondelefant_result_newindex(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1580   const char *result_type;
 | 
| 
jbe@23
 | 
  1581   // perform rawset, unless key is a string not starting with underscore:
 | 
| 
jbe/bsw@0
 | 
  1582   lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1583   if (lua_type(L, 2) != LUA_TSTRING || lua_tostring(L, 2)[0] == '_') {
 | 
| 
jbe/bsw@0
 | 
  1584     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1585     return 1;
 | 
| 
jbe/bsw@0
 | 
  1586   }
 | 
| 
jbe@23
 | 
  1587   // get value of "_class" attribute, or default class, when unset:
 | 
| 
jbe/bsw@0
 | 
  1588   lua_getfield(L, 1, "_class");  // 4
 | 
| 
jbe/bsw@0
 | 
  1589   if (!lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1590     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1591     lua_getfield(L,
 | 
| 
jbe/bsw@0
 | 
  1592       LUA_REGISTRYINDEX,
 | 
| 
jbe/bsw@0
 | 
  1593       MONDELEFANT_CLASS_PROTO_REGKEY
 | 
| 
jbe/bsw@0
 | 
  1594     );  // 4
 | 
| 
jbe/bsw@0
 | 
  1595   }
 | 
| 
jbe@23
 | 
  1596   // get value of "_type" attribute:
 | 
| 
jbe/bsw@0
 | 
  1597   lua_getfield(L, 1, "_type");  // 5
 | 
| 
jbe/bsw@0
 | 
  1598   result_type = lua_tostring(L, 5);
 | 
| 
jbe@23
 | 
  1599   // distinguish between lists and objects:
 | 
| 
jbe@23
 | 
  1600   if (result_type && !strcmp(result_type, "object")) {  // objects
 | 
| 
jbe/bsw@0
 | 
  1601     lua_settop(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1602     // try object setter functions:
 | 
| 
jbe/bsw@0
 | 
  1603     while (lua_toboolean(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1604       lua_getfield(L, 4, "object_set");  // 5
 | 
| 
jbe/bsw@0
 | 
  1605       lua_pushvalue(L, 2);  // 6
 | 
| 
jbe/bsw@0
 | 
  1606       lua_gettable(L, 5);  // 6
 | 
| 
jbe/bsw@0
 | 
  1607       if (lua_toboolean(L, 6)) {
 | 
| 
jbe/bsw@0
 | 
  1608         lua_pushvalue(L, 1);  // 7
 | 
| 
jbe/bsw@0
 | 
  1609         lua_pushvalue(L, 3);  // 8
 | 
| 
jbe/bsw@0
 | 
  1610         lua_call(L, 2, 0);
 | 
| 
jbe/bsw@0
 | 
  1611         return 0;
 | 
| 
jbe/bsw@0
 | 
  1612       }
 | 
| 
jbe/bsw@0
 | 
  1613       lua_settop(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1614       lua_pushliteral(L, "prototype");  // 5
 | 
| 
jbe/bsw@0
 | 
  1615       lua_rawget(L, 4);  // 5
 | 
| 
jbe/bsw@0
 | 
  1616       lua_replace(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1617     }
 | 
| 
jbe/bsw@0
 | 
  1618     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1619     // check, if a object reference is changed:
 | 
| 
jbe/bsw@0
 | 
  1620     lua_pushcfunction(L, mondelefant_class_get_reference);  // 4
 | 
| 
jbe/bsw@0
 | 
  1621     lua_getfield(L, 1, "_class");  // 5
 | 
| 
jbe/bsw@0
 | 
  1622     lua_pushvalue(L, 2);  // 6
 | 
| 
jbe/bsw@0
 | 
  1623     lua_call(L, 2, 1);  // 4
 | 
| 
jbe/bsw@0
 | 
  1624     if (!lua_isnil(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1625       // store object in _ref table (use false for nil):  // TODO: use special object instead of false
 | 
| 
jbe/bsw@0
 | 
  1626       lua_getfield(L, 1, "_ref");  // 5
 | 
| 
jbe/bsw@0
 | 
  1627       lua_pushvalue(L, 2);  // 6
 | 
| 
jbe/bsw@0
 | 
  1628       if (lua_isnil(L, 3)) lua_pushboolean(L, 0);  // 7
 | 
| 
jbe/bsw@0
 | 
  1629       else lua_pushvalue(L, 3);  // 7
 | 
| 
jbe/bsw@0
 | 
  1630       lua_settable(L, 5);
 | 
| 
jbe/bsw@0
 | 
  1631       lua_settop(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1632       // delete referencing key from _data table:
 | 
| 
jbe/bsw@0
 | 
  1633       lua_getfield(L, 4, "this_key");  // 5
 | 
| 
jbe/bsw@0
 | 
  1634       if (lua_isnil(L, 5)) {
 | 
| 
jbe/bsw@0
 | 
  1635         return luaL_error(L, "Missing 'this_key' entry in model reference.");
 | 
| 
jbe/bsw@0
 | 
  1636       }
 | 
| 
jbe/bsw@0
 | 
  1637       lua_getfield(L, 1, "_data");  // 6
 | 
| 
jbe/bsw@0
 | 
  1638       lua_pushvalue(L, 5);  // 7
 | 
| 
jbe/bsw@0
 | 
  1639       lua_pushnil(L);  // 8
 | 
| 
jbe/bsw@0
 | 
  1640       lua_settable(L, 6);
 | 
| 
jbe/bsw@0
 | 
  1641       lua_settop(L, 5);
 | 
| 
jbe/bsw@0
 | 
  1642       lua_getfield(L, 1, "_dirty");  // 6
 | 
| 
jbe/bsw@0
 | 
  1643       lua_pushvalue(L, 5);  // 7
 | 
| 
jbe/bsw@0
 | 
  1644       lua_pushboolean(L, 1);  // 8
 | 
| 
jbe/bsw@0
 | 
  1645       lua_settable(L, 6);
 | 
| 
jbe/bsw@0
 | 
  1646       return 0;
 | 
| 
jbe/bsw@0
 | 
  1647     }
 | 
| 
jbe/bsw@0
 | 
  1648     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1649     // store value in data field info:
 | 
| 
jbe/bsw@0
 | 
  1650     lua_getfield(L, 1, "_data");  // 4
 | 
| 
jbe/bsw@0
 | 
  1651     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1652     lua_pushvalue(L, 3);  // 6
 | 
| 
jbe/bsw@0
 | 
  1653     lua_settable(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1654     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1655     // mark field as dirty (needs to be UPDATEd on save):
 | 
| 
jbe/bsw@0
 | 
  1656     lua_getfield(L, 1, "_dirty");  // 4
 | 
| 
jbe/bsw@0
 | 
  1657     lua_pushvalue(L, 2);  // 5
 | 
| 
jbe/bsw@0
 | 
  1658     lua_pushboolean(L, 1);  // 6
 | 
| 
jbe/bsw@0
 | 
  1659     lua_settable(L, 4);
 | 
| 
jbe/bsw@0
 | 
  1660     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1661     // reset reference cache, if neccessary:
 | 
| 
jbe/bsw@0
 | 
  1662     lua_pushcfunction(L,
 | 
| 
jbe/bsw@0
 | 
  1663       mondelefant_class_get_foreign_key_reference_name
 | 
| 
jbe/bsw@0
 | 
  1664     );  // 4
 | 
| 
jbe/bsw@0
 | 
  1665     lua_getfield(L, 1, "_class");  // 5
 | 
| 
jbe/bsw@0
 | 
  1666     lua_pushvalue(L, 2);  // 6
 | 
| 
jbe/bsw@0
 | 
  1667     lua_call(L, 2, 1);  // 4
 | 
| 
jbe/bsw@0
 | 
  1668     if (!lua_isnil(L, 4)) {
 | 
| 
jbe/bsw@0
 | 
  1669       lua_getfield(L, 1, "_ref");  // 5
 | 
| 
jbe/bsw@0
 | 
  1670       lua_pushvalue(L, 4);  // 6
 | 
| 
jbe/bsw@0
 | 
  1671       lua_pushnil(L);  // 7
 | 
| 
jbe/bsw@0
 | 
  1672       lua_settable(L, 5);
 | 
| 
jbe/bsw@0
 | 
  1673     }
 | 
| 
jbe/bsw@0
 | 
  1674     return 0;
 | 
| 
jbe@23
 | 
  1675   } else {  // non-objects (i.e. lists)
 | 
| 
jbe@23
 | 
  1676     // perform rawset:
 | 
| 
jbe/bsw@0
 | 
  1677     lua_settop(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1678     lua_rawset(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1679     return 0;
 | 
| 
jbe/bsw@0
 | 
  1680   }
 | 
| 
jbe/bsw@0
 | 
  1681 }
 | 
| 
jbe/bsw@0
 | 
  1682 
 | 
| 
jbe@23
 | 
  1683 // meta-method "__index" of classes (models):
 | 
| 
jbe/bsw@0
 | 
  1684 static int mondelefant_class_index(lua_State *L) {
 | 
| 
jbe@23
 | 
  1685   // perform lookup in prototype:
 | 
| 
jbe/bsw@0
 | 
  1686   lua_settop(L, 2);
 | 
| 
jbe/bsw@0
 | 
  1687   lua_pushliteral(L, "prototype");  // 3
 | 
| 
jbe/bsw@0
 | 
  1688   lua_rawget(L, 1);  // 3
 | 
| 
jbe/bsw@0
 | 
  1689   lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1690   lua_gettable(L, 3);  // 4
 | 
| 
jbe/bsw@0
 | 
  1691   return 1;
 | 
| 
jbe/bsw@0
 | 
  1692 }
 | 
| 
jbe/bsw@0
 | 
  1693 
 | 
| 
jbe@23
 | 
  1694 // registration information for functions of library:
 | 
| 
jbe/bsw@0
 | 
  1695 static const struct luaL_Reg mondelefant_module_functions[] = {
 | 
| 
jbe/bsw@0
 | 
  1696   {"connect", mondelefant_connect},
 | 
| 
jbe/bsw@0
 | 
  1697   {"set_class", mondelefant_set_class},
 | 
| 
jbe/bsw@0
 | 
  1698   {"new_class", mondelefant_new_class},
 | 
| 
jbe/bsw@0
 | 
  1699   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1700 };
 | 
| 
jbe/bsw@0
 | 
  1701 
 | 
| 
jbe@23
 | 
  1702 // registration information for meta-methods of database connections:
 | 
| 
jbe/bsw@0
 | 
  1703 static const struct luaL_Reg mondelefant_conn_mt_functions[] = {
 | 
| 
jbe/bsw@0
 | 
  1704   {"__gc", mondelefant_conn_free},
 | 
| 
jbe/bsw@0
 | 
  1705   {"__index", mondelefant_conn_index},
 | 
| 
jbe/bsw@0
 | 
  1706   {"__newindex", mondelefant_conn_newindex},
 | 
| 
jbe/bsw@0
 | 
  1707   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1708 };
 | 
| 
jbe/bsw@0
 | 
  1709 
 | 
| 
jbe@23
 | 
  1710 // registration information for methods of database connections:
 | 
| 
jbe/bsw@0
 | 
  1711 static const struct luaL_Reg mondelefant_conn_methods[] = {
 | 
| 
jbe/bsw@0
 | 
  1712   {"close", mondelefant_conn_close},
 | 
| 
jbe/bsw@0
 | 
  1713   {"is_ok", mondelefant_conn_is_ok},
 | 
| 
jbe/bsw@0
 | 
  1714   {"get_transaction_status", mondelefant_conn_get_transaction_status},
 | 
| 
jbe/bsw@0
 | 
  1715   {"create_list", mondelefant_conn_create_list},
 | 
| 
jbe/bsw@0
 | 
  1716   {"create_object", mondelefant_conn_create_object},
 | 
| 
jbe/bsw@0
 | 
  1717   {"quote_string", mondelefant_conn_quote_string},
 | 
| 
jbe/bsw@0
 | 
  1718   {"quote_binary", mondelefant_conn_quote_binary},
 | 
| 
jbe/bsw@0
 | 
  1719   {"assemble_command", mondelefant_conn_assemble_command},
 | 
| 
jbe/bsw@0
 | 
  1720   {"try_query", mondelefant_conn_try_query},
 | 
| 
jbe/bsw@0
 | 
  1721   {"query", mondelefant_conn_query},
 | 
| 
jbe/bsw@0
 | 
  1722   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1723 };
 | 
| 
jbe/bsw@0
 | 
  1724 
 | 
| 
jbe@23
 | 
  1725 // registration information for meta-methods of error objects:
 | 
| 
jbe/bsw@0
 | 
  1726 static const struct luaL_Reg mondelefant_errorobject_mt_functions[] = {
 | 
| 
jbe/bsw@0
 | 
  1727   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1728 };
 | 
| 
jbe/bsw@0
 | 
  1729 
 | 
| 
jbe@23
 | 
  1730 // registration information for methods of error objects:
 | 
| 
jbe/bsw@0
 | 
  1731 static const struct luaL_Reg mondelefant_errorobject_methods[] = {
 | 
| 
jbe/bsw@0
 | 
  1732   {"escalate", mondelefant_errorobject_escalate},
 | 
| 
jbe/bsw@0
 | 
  1733   {"is_kind_of", mondelefant_errorobject_is_kind_of},
 | 
| 
jbe/bsw@0
 | 
  1734   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1735 };
 | 
| 
jbe/bsw@0
 | 
  1736 
 | 
| 
jbe@23
 | 
  1737 // registration information for meta-methods of database result lists/objects:
 | 
| 
jbe/bsw@0
 | 
  1738 static const struct luaL_Reg mondelefant_result_mt_functions[] = {
 | 
| 
jbe/bsw@0
 | 
  1739   {"__index", mondelefant_result_index},
 | 
| 
jbe/bsw@0
 | 
  1740   {"__newindex", mondelefant_result_newindex},
 | 
| 
jbe/bsw@0
 | 
  1741   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1742 };
 | 
| 
jbe/bsw@0
 | 
  1743 
 | 
| 
jbe@23
 | 
  1744 // registration information for methods of database result lists/objects:
 | 
| 
jbe/bsw@0
 | 
  1745 static const struct luaL_Reg mondelefant_class_mt_functions[] = {
 | 
| 
jbe/bsw@0
 | 
  1746   {"__index", mondelefant_class_index},
 | 
| 
jbe/bsw@0
 | 
  1747   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1748 };
 | 
| 
jbe/bsw@0
 | 
  1749 
 | 
| 
jbe@23
 | 
  1750 // registration information for methods of classes (models):
 | 
| 
jbe/bsw@0
 | 
  1751 static const struct luaL_Reg mondelefant_class_methods[] = {
 | 
| 
jbe/bsw@0
 | 
  1752   {"get_reference", mondelefant_class_get_reference},
 | 
| 
jbe/bsw@0
 | 
  1753   {"iterate_over_references", mondelefant_class_iterate_over_references},
 | 
| 
jbe/bsw@0
 | 
  1754   {"get_foreign_key_reference_name",
 | 
| 
jbe/bsw@0
 | 
  1755     mondelefant_class_get_foreign_key_reference_name},
 | 
| 
jbe/bsw@0
 | 
  1756   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1757 };
 | 
| 
jbe/bsw@0
 | 
  1758 
 | 
| 
jbe@23
 | 
  1759 // registration information for methods of database result objects (not lists!):
 | 
| 
jbe/bsw@0
 | 
  1760 static const struct luaL_Reg mondelefant_object_methods[] = {
 | 
| 
jbe/bsw@0
 | 
  1761   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1762 };
 | 
| 
jbe/bsw@0
 | 
  1763 
 | 
| 
jbe@23
 | 
  1764 // registration information for methods of database result lists (not single objects!):
 | 
| 
jbe/bsw@0
 | 
  1765 static const struct luaL_Reg mondelefant_list_methods[] = {
 | 
| 
jbe/bsw@0
 | 
  1766   {NULL, NULL}
 | 
| 
jbe/bsw@0
 | 
  1767 };
 | 
| 
jbe/bsw@0
 | 
  1768 
 | 
| 
jbe@23
 | 
  1769 // luaopen function to initialize/register library:
 | 
| 
jbe/bsw@0
 | 
  1770 int luaopen_mondelefant_native(lua_State *L) {
 | 
| 
jbe/bsw@0
 | 
  1771   lua_settop(L, 0);
 | 
| 
jbe/bsw@0
 | 
  1772   lua_newtable(L);  // module at stack position 1
 | 
| 
jbe@64
 | 
  1773 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1774   luaL_setfuncs(L, mondelefant_module_functions, 0);
 | 
| 
jbe@64
 | 
  1775 #else
 | 
| 
jbe/bsw@0
 | 
  1776   luaL_register(L, NULL, mondelefant_module_functions);
 | 
| 
jbe@64
 | 
  1777 #endif
 | 
| 
jbe/bsw@0
 | 
  1778 
 | 
| 
jbe/bsw@0
 | 
  1779   lua_pushvalue(L, 1);  // 2
 | 
| 
jbe/bsw@0
 | 
  1780   lua_setfield(L, LUA_REGISTRYINDEX, MONDELEFANT_MODULE_REGKEY);
 | 
| 
jbe/bsw@0
 | 
  1781 
 | 
| 
jbe/bsw@0
 | 
  1782   lua_newtable(L);  // 2
 | 
| 
jbe/bsw@0
 | 
  1783   // NOTE: only PostgreSQL is supported yet:
 | 
| 
jbe@64
 | 
  1784 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1785   luaL_setfuncs(L, mondelefant_conn_methods, 0);
 | 
| 
jbe@64
 | 
  1786 #else
 | 
| 
jbe/bsw@0
 | 
  1787   luaL_register(L, NULL, mondelefant_conn_methods);
 | 
| 
jbe@64
 | 
  1788 #endif
 | 
| 
jbe/bsw@0
 | 
  1789   lua_setfield(L, 1, "postgresql_connection_prototype");
 | 
| 
jbe/bsw@0
 | 
  1790   lua_newtable(L);  // 2
 | 
| 
jbe/bsw@0
 | 
  1791   lua_setfield(L, 1, "connection_prototype");
 | 
| 
jbe/bsw@0
 | 
  1792 
 | 
| 
jbe/bsw@0
 | 
  1793   luaL_newmetatable(L, MONDELEFANT_CONN_MT_REGKEY);  // 2
 | 
| 
jbe@64
 | 
  1794 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1795   luaL_setfuncs(L, mondelefant_conn_mt_functions, 0);
 | 
| 
jbe@64
 | 
  1796 #else
 | 
| 
jbe/bsw@0
 | 
  1797   luaL_register(L, NULL, mondelefant_conn_mt_functions);
 | 
| 
jbe@64
 | 
  1798 #endif
 | 
| 
jbe/bsw@0
 | 
  1799   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1800   luaL_newmetatable(L, MONDELEFANT_RESULT_MT_REGKEY);  // 2
 | 
| 
jbe@64
 | 
  1801 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1802   luaL_setfuncs(L, mondelefant_result_mt_functions, 0);
 | 
| 
jbe@64
 | 
  1803 #else
 | 
| 
jbe/bsw@0
 | 
  1804   luaL_register(L, NULL, mondelefant_result_mt_functions);
 | 
| 
jbe@64
 | 
  1805 #endif
 | 
| 
jbe/bsw@0
 | 
  1806   lua_setfield(L, 1, "result_metatable");
 | 
| 
jbe/bsw@0
 | 
  1807   luaL_newmetatable(L, MONDELEFANT_CLASS_MT_REGKEY);  // 2
 | 
| 
jbe@64
 | 
  1808 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1809   luaL_setfuncs(L, mondelefant_class_mt_functions, 0);
 | 
| 
jbe@64
 | 
  1810 #else
 | 
| 
jbe/bsw@0
 | 
  1811   luaL_register(L, NULL, mondelefant_class_mt_functions);
 | 
| 
jbe@64
 | 
  1812 #endif
 | 
| 
jbe/bsw@0
 | 
  1813   lua_setfield(L, 1, "class_metatable");
 | 
| 
jbe/bsw@0
 | 
  1814 
 | 
| 
jbe/bsw@0
 | 
  1815   lua_newtable(L);  // 2
 | 
| 
jbe@272
 | 
  1816 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@272
 | 
  1817   luaL_setfuncs(L, mondelefant_class_methods, 0);
 | 
| 
jbe@272
 | 
  1818 #else
 | 
| 
jbe@272
 | 
  1819   luaL_register(L, NULL, mondelefant_class_methods);
 | 
| 
jbe@272
 | 
  1820 #endif
 | 
| 
jbe/bsw@0
 | 
  1821   lua_newtable(L);  // 3
 | 
| 
jbe@64
 | 
  1822 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1823   luaL_setfuncs(L, mondelefant_object_methods, 0);
 | 
| 
jbe@64
 | 
  1824 #else
 | 
| 
jbe/bsw@0
 | 
  1825   luaL_register(L, NULL, mondelefant_object_methods);
 | 
| 
jbe@64
 | 
  1826 #endif
 | 
| 
jbe/bsw@0
 | 
  1827   lua_setfield(L, 2, "object");
 | 
| 
jbe/bsw@0
 | 
  1828   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
  1829   lua_setfield(L, 2, "object_get");
 | 
| 
jbe/bsw@0
 | 
  1830   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
  1831   lua_setfield(L, 2, "object_set");
 | 
| 
jbe/bsw@0
 | 
  1832   lua_newtable(L);  // 3
 | 
| 
jbe@64
 | 
  1833 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1834   luaL_setfuncs(L, mondelefant_list_methods, 0);
 | 
| 
jbe@64
 | 
  1835 #else
 | 
| 
jbe/bsw@0
 | 
  1836   luaL_register(L, NULL, mondelefant_list_methods);
 | 
| 
jbe@64
 | 
  1837 #endif
 | 
| 
jbe/bsw@0
 | 
  1838   lua_setfield(L, 2, "list");
 | 
| 
jbe/bsw@0
 | 
  1839   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
  1840   lua_setfield(L, 2, "references");
 | 
| 
jbe/bsw@0
 | 
  1841   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
  1842   lua_setfield(L, 2, "foreign_keys");
 | 
| 
jbe/bsw@0
 | 
  1843   lua_pushvalue(L, 2);  // 3
 | 
| 
jbe/bsw@0
 | 
  1844   lua_setfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CLASS_PROTO_REGKEY);
 | 
| 
jbe/bsw@0
 | 
  1845   lua_setfield(L, 1, "class_prototype");
 | 
| 
jbe/bsw@0
 | 
  1846 
 | 
| 
jbe/bsw@0
 | 
  1847   lua_newtable(L);  // 2
 | 
| 
jbe/bsw@0
 | 
  1848   lua_pushliteral(L, "k");  // 3
 | 
| 
jbe/bsw@0
 | 
  1849   lua_setfield(L, 2, "__mode");
 | 
| 
jbe/bsw@0
 | 
  1850   lua_newtable(L);  // 3
 | 
| 
jbe/bsw@0
 | 
  1851   lua_pushvalue(L, 2);  // 4
 | 
| 
jbe/bsw@0
 | 
  1852   lua_setmetatable(L, 3);
 | 
| 
jbe/bsw@0
 | 
  1853   lua_setfield(L, LUA_REGISTRYINDEX, MONDELEFANT_CONN_DATA_REGKEY);
 | 
| 
jbe/bsw@0
 | 
  1854   lua_settop(L, 1);
 | 
| 
jbe/bsw@0
 | 
  1855 
 | 
| 
jbe/bsw@0
 | 
  1856   luaL_newmetatable(L, MONDELEFANT_ERROROBJECT_MT_REGKEY);  // 2
 | 
| 
jbe@64
 | 
  1857 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1858   luaL_setfuncs(L, mondelefant_errorobject_mt_functions, 0);
 | 
| 
jbe@64
 | 
  1859 #else
 | 
| 
jbe/bsw@0
 | 
  1860   luaL_register(L, NULL, mondelefant_errorobject_mt_functions);
 | 
| 
jbe@64
 | 
  1861 #endif
 | 
| 
jbe/bsw@0
 | 
  1862   lua_newtable(L);  // 3
 | 
| 
jbe@64
 | 
  1863 #if LUA_VERSION_NUM >= 502
 | 
| 
jbe@64
 | 
  1864   luaL_setfuncs(L, mondelefant_errorobject_methods, 0);
 | 
| 
jbe@64
 | 
  1865 #else
 | 
| 
jbe/bsw@0
 | 
  1866   luaL_register(L, NULL, mondelefant_errorobject_methods);
 | 
| 
jbe@64
 | 
  1867 #endif
 | 
| 
jbe/bsw@0
 | 
  1868   lua_setfield(L, 2, "__index");
 | 
| 
jbe/bsw@0
 | 
  1869   lua_setfield(L, 1, "errorobject_metatable");
 | 
| 
jbe/bsw@0
 | 
  1870 
 | 
| 
jbe/bsw@0
 | 
  1871   return 1;
 | 
| 
jbe/bsw@0
 | 
  1872 }
 |