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