/*doc Memcached stats
Returns a Map with servers' statistics. Keys are server addresses,
values are maps with actual stats.
*/
IoObject *IoMemcached_stats(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoMap *results_map = IoMap_new(IOSTATE);
int errors = 0;
uint32_t pos = 0;
while(pos < memcached_server_count(DATA(self)->mc)) {
memcached_server_instance_st server = memcached_server_instance_by_position(DATA(self)->mc, pos);
if(server == NULL)
continue;
const char *hostname = memcached_server_name(server);
const in_port_t port = memcached_server_port(server);
memcached_stat_st stats;
memcached_return_t rc = memcached_stat_servername(&stats, "", hostname, port);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
char **ckeys = memcached_stat_get_keys(DATA(self)->mc, &stats, &rc);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
IoMap *per_server_map = IoMap_new(IOSTATE);
char *ckey = *ckeys;
while(ckey != NULL) {
char *cvalue = memcached_stat_get_value(DATA(self)->mc, &stats, ckey, &rc);
if(rc != MEMCACHED_SUCCESS) {
errors++;
continue;
}
IoMap_rawAtPut(per_server_map, IOSYMBOL(ckey), IOSYMBOL(cvalue));
free(cvalue);
ckey++;
}
free(ckeys);
// "127.0.0.1:11211"
char *server_key = (char *) malloc((strlen(hostname) + 1 + 5 + 1) * sizeof(char));
sprintf(server_key, "%s:%d", hostname, port);
IoMap_rawAtPut(results_map, IOSYMBOL(server_key), per_server_map);
free(server_key);
pos++;
}
if(errors > 0)
IoState_error_(IOSTATE, m, memcached_strerror(DATA(self)->mc, MEMCACHED_SOME_ERRORS));
return results_map;
}
IoMap *IoState_createAssignOperatorTable(IoState *state)
{
IoMap *self = IoMap_new(state);
IoMap_rawAtPut(self, IOSYMBOL(":="), IOSYMBOL("setSlot"));
IoMap_rawAtPut(self, IOSYMBOL("="), IOSYMBOL("updateSlot"));
IoMap_rawAtPut(self, IOSYMBOL("::="), IOSYMBOL("newSlot"));
return self;
}
/* format: addMember(name, type) */
IoObject* IoCInvokeStructure_addMember(IoCInvokeStructure* self, IoObject* locals, IoMessage* m) {
CInvContext* context = IoCInvokeLibrary_getContext_(IoObject_getSlot_(self, IOSYMBOL("library")));
if(!(DATA(self)->structure)) {
DATA(self)->structure = cinv_structure_create(context);
}
char* name = IoMessage_locals_cStringArgAt_(m, locals, 0);
IoObject *typeobj = IoMessage_locals_valueArgAt_(m, locals, 1);
if(ISCInvokeStructure(typeobj)) { /* adding a structure member! */
if(!cinv_structure_addmember_struct(context, DATA(self)->structure, name, DATA(typeobj)->structure)) {
printf("error with adding struct member\n");
}
} else { /* hopefully adding a DataType */
cinv_type_t type = IoCInvokeDataType_cinvType_t(typeobj);
if(!cinv_structure_addmember_value(context, DATA(self)->structure, name, type)) {
printf("error with adding value member\n");
}
}
// append it to the `memberTypes` Map
IoObject *memberTypes = IoObject_getSlot_(self, IOSYMBOL("memberTypes"));
IoMap_rawAtPut(memberTypes, IoMessage_locals_valueArgAt_(m, locals, 0), IoMessage_locals_valueArgAt_(m, locals, 1));
return self;
}
IoObject *IoRegex_namedCaptures(IoRegex *self, IoObject *locals, IoMessage *m)
{
/*doc Regex namedCaptures
Returns a Map that contains the index of each named group.
*/
IoMap *map = DATA(self)->namedCaptures;
NamedCapture *namedCaptures = 0, *capture = 0;
if (map)
return map;
map = DATA(self)->namedCaptures = IOREF(IoMap_new(IOSTATE));
capture = namedCaptures = Regex_namedCaptures(IoRegex_rawRegex(self));
if (!namedCaptures)
return map;
while (capture->name)
{
IoMap_rawAtPut(map, IOSYMBOL(capture->name), IONUMBER(capture->index));
capture++;
}
free(namedCaptures);
return map;
}
/*doc Memcached getMulti(keys)
Asks memcached to retrieve data corresponding to the list of keys.
Returns a Map with the results.
If some of the keys appearing in a retrieval request are not sent back
by the server in the item list this means that the server does not
hold items with such keys
*/
IoObject *IoMemcached_getMulti(IoMemcached *self, IoObject *locals, IoMessage *m)
{
IoList *keys_list = IoMessage_locals_listArgAt_(m, locals, 0);
size_t keys_list_size = IoList_rawSize(keys_list);
IoObject *results_map = IoMap_new(IOSTATE);
if(keys_list_size == 0)
return results_map;
int i;
for(i = 0; i < keys_list_size; i++) {
IoSeq *key = IoList_rawAt_(keys_list, i);
IOASSERT(ISSEQ(key), "key must be a Sequence");
IOASSERT(IOSEQ_LENGTH(key) > 0, "key cannot be an empty Sequence");
IOASSERT(IOSEQ_LENGTH(key) < MEMCACHED_MAX_KEY, "key is too long");
}
const char **ckeys = (const char **) malloc(sizeof(const char *) * keys_list_size);
size_t *ckey_lengths = (size_t *) malloc(sizeof(size_t) * keys_list_size);
for(i = 0; i < keys_list_size; i++) {
ckeys[i] = CSTRING(IoList_rawAt_(keys_list, i));
ckey_lengths[i] = strlen(ckeys[i]);
}
memcached_return_t rc = memcached_mget(DATA(self)->mc, ckeys, ckey_lengths, keys_list_size);
free(ckeys);
free(ckey_lengths);
char returned_key[MEMCACHED_MAX_KEY], *returned_value;
size_t returned_key_length, returned_value_length;
uint32_t flags;
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
while(returned_value != NULL) {
IoMap_rawAtPut(results_map,
IoSeq_newSymbolWithData_length_(IOSTATE, returned_key, returned_key_length),
IoMemcached_deserialize(self, returned_value, returned_value_length, flags)
);
free(returned_value);
returned_value = memcached_fetch(DATA(self)->mc,
returned_key, &returned_key_length,
&returned_value_length, &flags, &rc
);
}
return results_map;
}
IoCFFIPointer *IoCFFIPointer_ToType_(IoObject *type)
{
IoObject *pointer, *self;
IoMap *pointers;
IoSymbol *key;
// this is a hack so macros relying on self will work
self = type;
pointers = IoObject_getSlot_(IoState_protoWithInitFunction_(IOSTATE, IoCFFIPointer_proto), IOSYMBOL("pointers"));
key = IoState_on_doCString_withLabel_(IOSTATE, type, "uniqueHexId", "IoCFFIPointer_ToType_");
pointer = IoMap_rawAt(pointers, key);
if (!pointer)
{
// create new pointer and add to cache
pointer = IoCFFIPointer_new(IOSTATE);
IoObject_setSlot_to_(pointer, IOSYMBOL("pointedToType"), type);
IoMap_rawAtPut(pointers, key, pointer);
}
return pointer;
}
IoObject* IoMySQL_query(IoObject* self, IoObject* locals, IoMessage* m)
{
/*doc MySQL query(aQueryString)
Perform a SQL query and return a list of results.
<pre>
db query("SELECT * FROM accounts") foreach(println)
</pre>
*/
IoObject * queryString = 0x0;
bool useMap;
MYSQL* conn = &DATA(self)->connection;
MYSQL_RES* result;
MYSQL_ROW row;
MYSQL_FIELD* column;
char** columnNames;
unsigned c, colLength;
unsigned long* colLengths;
IoObject *list, *rowObject; //, *tmpObject;
if(IoMessage_argCount(m) < 1 || !ISSEQ(queryString = IoMessage_locals_quickValueArgAt_(m, locals, 0)))
IoState_error_(IOSTATE, m, "argument 0 to method 'query' must be a Sequence");
useMap = IoMessage_argCount(m) > 1 && ISTRUE(IoMessage_locals_quickValueArgAt_(m, locals, 1));
if(!DATA(self)->connected) //printf("not connected?\n");
IoState_error_(IOSTATE, m, "not connected yet");
if(mysql_real_query(conn, CSTRING(queryString), IOSEQ_LENGTH(queryString)))
IoState_error_(IOSTATE, m, "query error(%d): %s", mysql_errno(&DATA(self)->connection), mysql_error(&DATA(self)->connection));
if((result = mysql_store_result(conn)) && (colLength = mysql_num_fields(result))) {
list = IoList_new(IOSTATE);
if(useMap) {
columnNames = (char**) malloc(colLength * sizeof(char*));
for(c = 0; c < colLength && (column = mysql_fetch_field(result)); ++c)
columnNames[c] = column->name;
while((row = mysql_fetch_row(result)))
{
colLengths = mysql_fetch_lengths(result);
rowObject = IoMap_new(IOSTATE);
for(c = 0; c < colLength; ++c)
IoMap_rawAtPut(rowObject, IOSYMBOL(columnNames[c]), IOSEQ((unsigned char *)row[c], (size_t)colLengths[c]));
IoList_rawAppend_(list, rowObject);
}
free(columnNames);
}
else
{
while((row = mysql_fetch_row(result))) {
colLengths = mysql_fetch_lengths(result);
rowObject = IoList_new(IOSTATE);
for(c = 0; c < colLength; ++c)
IoList_rawAppend_(rowObject, IOSEQ((unsigned char *)row[c], (size_t)colLengths[c]));
IoList_rawAppend_(list, rowObject);
}
}
mysql_free_result(result);
return list;
}
else
return IONUMBER(mysql_affected_rows(conn));
}
IoMap *IoState_createOperatorTable(IoState *state)
{
typedef struct OpTable {
char *symbol;
int precedence;
} OpTable;
OpTable ops[] = {
{"@", 0},
{"@@", 0},
{"?", 0},
{"**", 1},
{"*", 2},
{"/", 2},
{"%", 2},
{"+", 3},
{"-", 3},
{"<<", 4},
{">>", 4},
{">", 5},
{"<", 5},
{"<=", 5},
{">=", 5},
{"==", 6},
{"!=", 6},
{"&", 7},
{"^", 8},
{"|", 9},
{"and", 10},
{"&&", 10},
{"or", 11},
{"||", 11},
{"..", 12},
{"+=", 13},
{"-=", 13},
{"*=", 13},
{"/=", 13},
{"%=", 13},
{"&=", 13},
{"^=", 13},
{"|=", 13},
{"<<=", 13},
{">>=", 13},
{"return", 14},
{NULL, 0},
};
IoMap *self = IoMap_new(state);
OpTable *op = ops;
while (op->symbol)
{
IoMap_rawAtPut(self, IOSYMBOL(op->symbol), IONUMBER(op->precedence));
op ++;
}
return self;
}
