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