Timestamp written as a string so escape required

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: rmodb
 Title: Metadata-Object pair database
-Version: 0.0.1
+Version: 0.1.0
 Author: Craig Williams [aut, cre]
 Maintainer: Craig Williams <craig@avsdev.uk>
 Description: RMODB implements a metadata-object database for storing R 
@@ -18,7 +18,7 @@ Encoding: UTF-8
 NeedsCompilation: yes
 LazyData: true
 Roxygen: list(markdown = TRUE)
-RoxygenNote: 7.0.2
+RoxygenNote: 7.1.1
 Suggests: 
     testthat
 SystemRequirements: libmariadb-client-dev | libmariadb-client-lgpl-dev | libmysqlclient-dev (deb)

NAMESPACE

@@ -4,6 +4,7 @@ export(TYPE_BLOB)
 export(TYPE_BOOL)
 export(TYPE_DOUBLE)
 export(TYPE_FLOAT)
+export(TYPE_ID)
 export(TYPE_INT16)
 export(TYPE_INT32)
 export(TYPE_INT64)
@@ -15,6 +16,23 @@ export(TYPE_UINT16)
 export(TYPE_UINT32)
 export(TYPE_UINT64)
 export(TYPE_UINT8)
+export(group)
+export(group_create)
+export(group_delete)
+export(group_exists)
+export(group_id)
+export(groups)
+export(link_user_group)
+export(metadata)
+export(metadata_query)
+export(metadatas)
+export(metaobject)
+export(metaobject_create)
+export(metaobject_delete)
+export(metaobject_ids)
+export(metaobject_query)
+export(metaobject_update)
+export(metaobjects)
 export(modb_conn_ref)
 export(modb_connect)
 export(modb_connectionExists)
@@ -26,4 +44,14 @@ export(modb_destroy)
 export(modb_disconnect)
 export(modb_exists)
 export(modb_use)
+export(object)
+export(object_query)
+export(objects)
+export(unlink_user_group)
+export(user)
+export(user_create)
+export(user_delete)
+export(user_exists)
+export(user_id)
+export(users)
 useDynLib(rmodb, .registration = TRUE, .fixes = "c_")

R/Database.R

@@ -231,3 +231,9 @@ modb_use <- function(modb_name, override = FALSE, ...) {
   res <- .Call(c_rmodb_use, conn_ref, modb_name, as.logical(override))
   return(res)
 }
+
+modb_get_last_query <- function(...) {
+  conn_ref <- modb_conn_ref(args = list(...))
+  res <- .Call(c_rmodb_getLastQuery, conn_ref)
+  return(res)
+}

R/Groups.R

@@ -1,4 +1,5 @@
 
+#' @export
 group_id <- function(name, ...) {
   checkmate::assert_string(name)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -6,9 +7,11 @@ group_id <- function(name, ...) {
   res <- .Call(c_rmodb_groupId, conn_ref, name)
   return(res)
 }
+#' @export
 group_exists <- function(name, ...) {
   return(!is.na(group_id(name)))
 }
+#' @export
 group_create <- function(name, id = NULL, ...) {
   checkmate::assert_string(name)
   if (!checkmate::test_null(id)) {
@@ -21,6 +24,7 @@ group_create <- function(name, id = NULL, ...) {
   res <- .Call(c_rmodb_createGroup, conn_ref, as.integer(id), name)
   return(res)
 }
+#' @export
 group_delete <- function(id, ...) {
   checkmate::assert_int(id)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -28,6 +32,7 @@ group_delete <- function(id, ...) {
   res <- .Call(c_rmodb_deleteGroup, conn_ref, as.integer(id))
   return(res)
 }
+#' @export
 group <- function(id, withMembers = TRUE, ...) {
   checkmate::assert_int(id)
   checkmate::assert_logical(withMembers)
@@ -36,6 +41,7 @@ group <- function(id, withMembers = TRUE, ...) {
   res <- .Call(c_rmodb_group, conn_ref, as.integer(id), as.logical(withMembers))
   return(res)
 }
+#' @export
 groups <- function(withMembers = FALSE, withDeleted = FALSE, ...)
 {
   checkmate::assert_logical(withMembers)

R/Metaobject.R

@@ -1,13 +1,58 @@
 
-metaobject_ids <- function(title, ...) {
-  checkmate::assert_string(title)
+#' @export
+metaobject_ids <- function(query = list(), withDeleted = FALSE, ...) {
+  checkmate::assert_list(query)
+  checkmate::assert_logical(withDeleted)
   conn_ref <- modb_conn_ref(args = list(...))
 
-  res <- .Call(c_rmodb_metaobjectId, conn_ref, title)
+  res <- .Call(c_rmodb_metaobjectIds, conn_ref, query, withDeleted)
+
+  return(res)
+}
+#' @export
+metaobject_query <- function(query = list(), withDeleted = FALSE, restrict_owner = 0, ...) {
+  checkmate::assert_list(query)
+  checkmate::assert_logical(withDeleted)
+  checkmate::assert_int(restrict_owner)
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(
+    c_rmodb_metaobjectQuery, conn_ref,
+    query, withDeleted, as.integer(restrict_owner)
+  )
+
+  return(res)
+}
+#' @export
+metadata_query <- function(query = list(), withDeleted = FALSE, restrict_owner = 0, ...) {
+  checkmate::assert_list(query)
+  checkmate::assert_logical(withDeleted)
+  checkmate::assert_int(restrict_owner)
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(
+    c_rmodb_metadataQuery, conn_ref,
+    query, withDeleted, as.integer(restrict_owner)
+  )
+
+  return(res)
+}
+#' @export
+object_query <- function(query = list(), withDeleted = FALSE, restrict_owner = 0, ...) {
+  checkmate::assert_list(query)
+  checkmate::assert_logical(withDeleted)
+  checkmate::assert_int(restrict_owner)
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(
+    c_rmodb_metadataQuery, conn_ref,
+    query, withDeleted, as.integer(restrict_owner)
+  )
 
   return(res)
 }
 
+#' @export
 metaobject_create <- function(meta, obj, id = NULL, ...) {
   if (!checkmate::test_null(id)) {
     checkmate::assert_int(id)
@@ -61,17 +106,87 @@ metaobject_create <- function(meta, obj, id = NULL, ...) {
     "created_on", "updated_on", "deleted_on"
   )
   ext <- meta[!(names(meta) %in% meta_fields)]
-  meta <- meta[names(meta) %in% c("title", "owner_id", "group_ids")]
+  meta <- meta[names(meta) %in% meta_fields]
+
+
+  # utils::str(meta)
+  # utils::str(ext)
+  # utils::str(obj)
+
+  res <- .Call(c_rmodb_createMetaobject, conn_ref, as.integer(id), meta, obj, ext)
+
+  return(res)
+}
+
+#' @export
+metaobject_update <- function(id, meta, obj, ...) {
+  checkmate::assert_int(id)
+
+  # TODO: validate meta and obj
+  # checkmate::assert_list(meta)
+  # checkmate::assert_names(names(meta), must.include = c("title"))
+  # assert_namesInclude(names(meta), one.of = c("owner", "owner_id"))
+  # if (test_namesInclude(names(meta), all.of = c("owner"))) {
+  #   checkmate::assert_class(meta$owner, "modb_user")
+  #   meta$owner_id <- meta$owner$id
+  # } else {
+  #   checkmate::assert_int(meta$owner_id)
+  # }
+  # meta$owner_id <- as.integer(meta$owner_id)
+
+  # assert_namesInclude(names(meta), one.of = c("groups", "group_ids"))
+  # if (checkmate::test_null(meta$group_ids)) {
+  #   meta$group_ids <- list()
+  # } else if (test_namesInclude(names(meta), all.of = c("groups"))) {
+  #   meta$group_ids <- list()
+  #   for (g in meta$groups) {
+  #     checkmate::assert_class(g, "modb_group")
+  #     meta$group_ids <- c(meta$group_ids, g$id)
+  #   }
+  # } else if (checkmate::test_list(meta$group_ids)) {
+  #   if (length(meta$group_ids) > 0) {
+  #     checkmate::assert_integerish(unlist(meta$group_ids))
+  #   }
+  # } else {
+  #   checkmate::assert_integerish(meta$group_ids)
+  # }
+  # meta$group_ids <- c(as.integer(meta$group_ids))
+
+
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  if (!missing(meta)) {
+    meta_fields <- c(
+      "id", "title", "owner_id", "owner", "groups", "group_ids",
+      "created_on", "updated_on", "deleted_on"
+    )
+    ext <- meta[!(names(meta) %in% meta_fields)]
+    meta <- meta[names(meta) %in% meta_fields[-1]]
+    if (length(meta) == 0) {
+      meta <- list(NULL)
+    }
+    if (length(ext) == 0) {
+      ext <- list(NULL)
+    }
+  } else {
+    meta <- list(NULL)
+    ext <- list(NULL)
+  }
+
+  if (missing(obj)) {
+    obj <- list(NULL)
+  }
 
 
   utils::str(meta)
   utils::str(ext)
   utils::str(obj)
 
-  res <- .Call(c_rmodb_createMetaobject, conn_ref, as.integer(id), meta, obj, ext)
+  res <- .Call(c_rmodb_updateMetaobject, conn_ref, as.integer(id), meta, obj, ext)
 
   return(res)
 }
+#' @export
 metaobject_delete <- function(id, ...) {
   checkmate::assert_int(id)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -79,6 +194,8 @@ metaobject_delete <- function(id, ...) {
   res <- .Call(c_rmodb_deleteMetaobject, conn_ref, as.integer(id))
   return(res)
 }
+
+#' @export
 metaobject <- function(id, ...) {
   checkmate::assert_int(id)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -87,7 +204,8 @@ metaobject <- function(id, ...) {
 
   return(res)
 }
-metaobjects <- function(withDeleted = FALSE, ...)
+#' @export
+metaobjects <- function(id_list = NULL, withDeleted = FALSE, ...)
 {
   checkmate::assert_logical(withDeleted)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -98,3 +216,51 @@ metaobjects <- function(withDeleted = FALSE, ...)
 
   return(res)
 }
+
+#' @export
+metadata <- function(id, ...) {
+  checkmate::assert_int(id)
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(c_rmodb_metaobject, conn_ref, as.integer(id))
+  res[names(res) %in% c("object")] <- NULL
+
+  return(res)
+}
+#' @export
+metadatas <- function(id_list = NULL, withDeleted = FALSE, ...) {
+  if (!checkmate::test_null(id_list)) {
+    return(lapply(
+      id_list, rmodb:::metadata, conn_ref = conn_id, withDeleted = withDeleted
+    ))
+  }
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(c_rmodb_metadatas, conn_ref, as.logical(withDeleted))
+
+  return(res)
+}
+
+#' @export
+object <- function(id, ...) {
+  checkmate::assert_int(id)
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(c_rmodb_metaobject, conn_ref, as.integer(id))
+
+  return(res$object)
+}
+#' @export
+objects <- function(id_list = NULL, withDeleted = FALSE, ...) {
+  if (!checkmate::test_null(id_list)) {
+    return(lapply(
+      id_list, rmodb:::object, conn_ref = conn_id, withDeleted = withDeleted
+    ))
+  }
+
+  conn_ref <- modb_conn_ref(args = list(...))
+
+  res <- .Call(c_rmodb_metaobjects, conn_ref, as.logical(withDeleted))
+
+  return(res$object)
+}

R/UserGroups.R

@@ -1,4 +1,5 @@
 
+#' @export
 link_user_group <- function(user, group, ...) {
   conn_ref <- modb_conn_ref(args = list(...))
   if (checkmate::test_list(user)) {
@@ -21,6 +22,7 @@ link_user_group <- function(user, group, ...) {
   return(res)
 }
 
+#' @export
 unlink_user_group <- function(user, group, ...) {
   conn_ref <- modb_conn_ref(args = list(...))
   if (checkmate::test_list(user)) {

R/Users.R

@@ -1,4 +1,5 @@
 
+#' @export
 user_id <- function(name, ...) {
   checkmate::assert_string(name)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -6,9 +7,11 @@ user_id <- function(name, ...) {
   res <- .Call(c_rmodb_userId, conn_ref, name)
   return(res)
 }
+#' @export
 user_exists <- function(name, ...) {
   return(!is.na(user_id(name)))
 }
+#' @export
 user_create <- function(name, email,  id = NULL, ...) {
   checkmate::assert_string(name)
   checkmate::assert_string(email)
@@ -22,6 +25,7 @@ user_create <- function(name, email,  id = NULL, ...) {
   res <- .Call(c_rmodb_createUser, conn_ref, as.integer(id), name, email)
   return(res)
 }
+#' @export
 user_delete <- function(id, ...) {
   checkmate::assert_int(id)
   conn_ref <- modb_conn_ref(args = list(...))
@@ -29,6 +33,7 @@ user_delete <- function(id, ...) {
   res <- .Call(c_rmodb_deleteUser, conn_ref, as.integer(id))
   return(res)
 }
+#' @export
 user <- function(id, withGroups = TRUE, ...) {
   checkmate::assert_int(id)
   checkmate::assert_logical(withGroups)
@@ -38,6 +43,7 @@ user <- function(id, withGroups = TRUE, ...) {
 
   return(res)
 }
+#' @export
 users <- function(withGroups = FALSE, withDeleted = FALSE, ...)
 {
   checkmate::assert_logical(withGroups)

man/modb_conn_ref.Rd

@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/Manage.R
+% Please edit documentation in R/Database.R
 \name{modb_conn_ref}
 \alias{modb_conn_ref}
 \title{MODB Connection References}

man/modb_connect.Rd

@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/Manage.R
+% Please edit documentation in R/Database.R
 \name{modb_connect}
 \alias{modb_connect}
 \title{MODB Connections}

man/modb_connectionInfo.Rd

@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/Manage.R
+% Please edit documentation in R/Database.R
 \name{modb_connectionInfo}
 \alias{modb_connectionInfo}
 \alias{modb_connectionExists}

man/modb_disconnect.Rd

@@ -1,5 +1,5 @@
 % Generated by roxygen2: do not edit by hand
-% Please edit documentation in R/Manage.R
+% Please edit documentation in R/Database.R
 \name{modb_disconnect}
 \alias{modb_disconnect}
 \title{MODB Connections}

src/Makevars.in

@@ -1,10 +1,12 @@
-PKG_CPPFLAGS=@cflags@
+PKG_CPPFLAGS=@cflags@ -DDEBUG -DSQL_DEBUG_MAX_LEN=2048
 PKG_LIBS=@libs@
 
 all: clean
 
 clean:
 	rm -f $(SHLIB) $(OBJECTS)
+
+#OBJECTS = $(patsubst %.c,%.o,$(wildcard *.c))
 OBJECTS = $(DB_OBJECTS) $(MODB_OBJECTS) $(R_OBJECTS) strext.o
 DB_OBJECTS = $(patsubst %.c,%.o,$(wildcard db_*.c))
 MODB_OBJECTS = $(patsubst %.c,%.o,$(wildcard modb_*.c))

src/R_modb_manage.c

@@ -236,3 +236,20 @@ SEXP rmodb_use(SEXP r_conn_ref, SEXP r_name, SEXP r_override)
 
   return Rf_ScalarLogical(TRUE);
 }
+
+
+SEXP rmodb_getLastQuery(SEXP r_conn_ref)
+{
+  stored_conn *sconn;
+  SEXP r_res;
+
+  if ((sconn = getConnectionByRef(r_conn_ref)) == 0) {
+    Rf_error("invalid connection reference\n");
+  }
+
+  r_res = Rf_allocVector(STRSXP, 1);
+  SET_STRING_ELT(r_res, 0, PROTECT(Rf_mkCharLen(sconn->last_qry, (int)sconn->last_qry_len)));
+
+  UNPROTECT(2);
+  return r_res;
+}

src/R_modb_manage.h

@@ -24,4 +24,6 @@ SEXP rmodb_destroy(SEXP r_conn_ref, SEXP r_name);
 SEXP rmodb_use(SEXP r_conn_ref, SEXP r_name, SEXP r_override);
 
 
+SEXP rmodb_getLastQuery(SEXP r_conn_ref);
+
 #endif // H__R_MODB_MANAGE__

src/R_modb_metaobjects.c

@@ -3,6 +3,7 @@
 
 #include "modb_database.h"
 #include "modb_ref.h"
+#include "modb_users.h"
 #include "R_helpers_p.h"
 #include "R_list_item.h"
 #include "R_timestamp.h"
@@ -12,6 +13,8 @@
 #include "R_memory-object.h"
 #include "R_magic.h"
 
+#include "modb_p.h" // ARGH!
+
 
 
 SEXP metadataToR(struct metadata_t *metadata)
@@ -121,41 +124,68 @@ SEXP metadataExtToR(struct meta_ext_t *ext)
   struct meta_ext_value_t *ext_value;
 
 
-  r_ext = PROTECT(Rf_allocVector(VECSXP, 1 + (int)ext->n_values));
+  r_ext = PROTECT(Rf_allocVector(VECSXP, 0 + (int)ext->n_values));
   n_protect++;
 
-  r_attrib_names = PROTECT(Rf_allocVector(STRSXP, 1 + (int)ext->n_values));
+  r_attrib_names = PROTECT(Rf_allocVector(STRSXP, 0 + (int)ext->n_values));
   n_protect++;
 
+  //printf("MAKING EXT\n");
+
   for (idx = 0; idx < ext->n_values; idx++) {
     ext_value = *(ext->values + idx);
+    //printf("%d, %s, %d, %p\n", ext_value->is_null, ext_value->key_c, ext_value->type, ext_value->value.raw);
     switch(ext_value->type) {
       case VTYPE_RAW:
           r_tmp = PROTECT(objectToR(ext_value->value.raw));
         break;
       case VTYPE_BOOL:
-        r_tmp = PROTECT(Rf_ScalarLogical(ext_value->value.bool));
+        if (ext_value->is_null) {
+          r_tmp = PROTECT(Rf_ScalarLogical(R_NaInt));
+        } else {
+          r_tmp = PROTECT(Rf_ScalarLogical(ext_value->value.boolVal));
+        }
         break;
       case VTYPE_INT32:
+        if (ext_value->is_null) {
+          r_tmp = PROTECT(Rf_ScalarInteger(R_NaInt));
+        } else {
           r_tmp = PROTECT(Rf_ScalarInteger(ext_value->value.int32));
+        }
         break;
       case VTYPE_DOUBLE:
+        if (ext_value->is_null) {
+          r_tmp = PROTECT(Rf_ScalarReal(R_NaReal));
+        } else {
           r_tmp = PROTECT(Rf_ScalarReal(ext_value->value.dbl));
+        }
         break;
       case VTYPE_STRING:
         r_tmp = PROTECT(Rf_allocVector(STRSXP, 1));
         n_protect++;
+        if (ext_value->is_null) {
+          SET_STRING_ELT(r_tmp, 0, PROTECT(R_NaString));
+        } else {
           SET_STRING_ELT(r_tmp, 0, PROTECT(Rf_mkChar(ext_value->value.str)));
+        }
         break;
       case VTYPE_TIMESTAMP:
+        if (ext_value->is_null) {
+          r_tmp = PROTECT(Rf_ScalarReal(R_NaReal));
+        } else {
           r_tmp = PROTECT(R_Timestamp(ext_value->value.ts));
+        }
         break;
       case VTYPE_ID:
+        if (ext_value->is_null) {
+          r_tmp = PROTECT(Rf_ScalarInteger(R_NaInt));
+        } else {
           r_tmp = PROTECT(Rf_ScalarInteger((int)ext_value->value.id));
+        }
         break;
     }
-    SET_VECTOR_ELT(r_ext, 1 + (int)idx, r_tmp);
-    SET_STRING_ELT(r_attrib_names, 1 + (int)idx, PROTECT(Rf_mkChar(ext_value->key_c)));
+    SET_VECTOR_ELT(r_ext, 0 + (int)idx, r_tmp);
+    SET_STRING_ELT(r_attrib_names, 0 + (int)idx, PROTECT(Rf_mkChar(ext_value->key_c)));
     n_protect += 2;
   }
 
@@ -165,10 +195,368 @@ SEXP metadataExtToR(struct meta_ext_t *ext)
   return r_ext;
 }
 
-SEXP rmodb_metaobjectId(SEXP r_conn_ref, SEXP r_query)
+SEXP rmodb_metaobjectQuery(SEXP r_conn_ref, SEXP r_query, SEXP r_with_deleted,
+                           SEXP r_owner_restrict)
 {
+  stored_conn *sconn;
+  modb_ref modb;
+  SEXP r_query_names;
+  SEXP r_tmp;
+  SEXP r_metadatas;
+  int i;
+  const char *col;
+  const char *tmp_str;
+  where_builder *wb = 0, *wb_in = 0;
+  struct user_t user;
+  struct metadata_t *metadata;
+  struct metadata_t **metadata_list;
+  size_t n_metadatas;
+  size_t idx, n_ids, m_idx;
+  unsigned int *ids;
+  char *table;
+  size_t table_len;
+
+  if ((sconn = getConnectionByRef(r_conn_ref)) == 0) {
+    Rf_error("invalid connection reference\n");
+  }
+
+  if (!modbFindUse(sconn, &modb)) {
+    Rf_error("invalid modb reference\n");
+  }
+
+  bzero(&user, sizeof(struct user_t));
+  user.id = (unsigned int)Rf_asInteger(r_owner_restrict);
+  if (user.id > 0) {
+    wb = where(0, "owner_id", EQ, TYPE_ID, 1, user.id);
+
+    if (!modbFetchUserGroupIds(sconn, &modb, &user)) {
+      Rf_error("invalid user id\n");
+    }
+    if (user.n_groups > 0) {
+      for (idx = 0; idx < user.n_groups; idx++) {
+        if (modbFetchGroupMetadataIds(sconn, &modb, *(user.group_ids + idx), &ids, &n_ids) < 0) {
+          free(user.groups);
           return R_NilValue;
         }
+        for (m_idx = 0; m_idx < n_ids; m_idx++) {
+          if (wb_in == 0) {
+            modbTableName(&table, &table_len, &modb, METADATA_TABLE, STR_LEN(METADATA_TABLE));
+            wb_in = whereIn(0, table, "mdo_id", TYPE_ID, 0);
+            modbFreeTableName(&table);
+          }
+          setWhereValue(wb_in, TYPE_ID, 1, *(ids + m_idx));
+        }
+        free(ids);
+      }
+      free(user.groups);
+
+      if (wb_in != 0) {
+        wb = createWhereBuilder(wb);
+        wb = whereAnd(0, whereOr(wb, wb_in));
+      }
+    }
+  }
+
+  if (Rf_asLogical(r_with_deleted) == 0) {
+    wb = whereAnd(wb, where(0, "deleted", IS_NULL, TYPE_RAW, 0));
+  }
+  r_query_names = Rf_getAttrib(r_query, R_NamesSymbol);
+  for (i = 0; i < LENGTH(r_query); i++) {
+    col = Rf_translateCharUTF8(STRING_ELT(r_query_names, i));
+    r_tmp = VECTOR_ELT(r_query, i);
+    if (Rf_isNull(r_tmp)) {
+      wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+    } else {
+      switch(TYPEOF(r_tmp)) {
+        case LGLSXP:/* logical vectors */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_BOOL, 1, Rf_asLogical(r_tmp)));
+          break;
+        case INTSXP:/* integer vectors */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_INT32, 1, Rf_asInteger(r_tmp)));
+          break;
+        case REALSXP:/* real variables */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_DOUBLE, 1, Rf_asReal(r_tmp)));
+          break;
+        case STRSXP:/* string vectors */
+          r_tmp = STRING_ELT(r_tmp, 0);
+          if (r_tmp == R_NaString) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            tmp_str = Rf_translateCharUTF8(r_tmp);
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_STRING, 2, tmp_str, strlen(tmp_str)));
+          }
+          break;
+        case VECSXP:/* generic vectors */
+          break;
+        default:
+          break;
+          // Screwed if I know how to handle this...
+      }
+    }
+  }
+
+  if (modbMetadataQuery(sconn, &modb, wb, &metadata_list, &n_metadatas) <= 0) {
+    freeWhereBuilder(&wb);
+    return R_NilValue;
+  }
+  freeWhereBuilder(&wb);
+
+  r_metadatas = PROTECT(Rf_allocVector(VECSXP, (int)n_metadatas));
+  for (idx = 0; idx < n_metadatas; idx++) {
+    metadata = *(metadata_list + idx);
+
+    if (modbFetchMetadataOwner(sconn, &modb, metadata) < 0) {
+      freeMetadata(&metadata);
+      UNPROTECT(1 + (int)idx);
+      return R_NilValue;
+    }
+    if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) < 0) {
+      freeMetadataList(&metadata_list, n_metadatas);
+      UNPROTECT(1 + (int)idx);
+      return R_NilValue;
+    }
+//    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
+//      freeMetadataList(&metadata_list, n_metadatas);
+//      UNPROTECT(1 + (int)idx);
+//      return R_NilValue;
+//    }
+    if (modbFetchMetadataObject(sconn, &modb, metadata) < 0) {
+      freeMetadataList(&metadata_list, n_metadatas);
+      UNPROTECT(1 + (int)idx);
+      return R_NilValue;
+    }
+
+    SET_VECTOR_ELT(r_metadatas, (int)idx, PROTECT(metadataToR(metadata)));
+  }
+  freeMetadataList(&metadata_list, n_metadatas);
+
+  UNPROTECT((int)(1 + n_metadatas));
+  return r_metadatas;
+}
+
+SEXP rmodb_metadataQuery(SEXP r_conn_ref, SEXP r_query, SEXP r_with_deleted, SEXP r_owner_restrict)
+{
+  stored_conn *sconn;
+  modb_ref modb;
+  SEXP r_query_names;
+  SEXP r_tmp;
+  SEXP r_metadatas;
+  int i;
+  const char *col;
+  const char *tmp_str;
+  where_builder *wb = 0, *wb_in = 0;
+  struct user_t user;
+  struct metadata_t *metadata;
+  struct metadata_t **metadata_list;
+  size_t n_metadatas;
+  size_t idx, n_ids, m_idx;
+  unsigned int *ids;
+  char *table;
+  size_t table_len;
+
+  if ((sconn = getConnectionByRef(r_conn_ref)) == 0) {
+    Rf_error("invalid connection reference\n");
+  }
+
+  if (!modbFindUse(sconn, &modb)) {
+    Rf_error("invalid modb reference\n");
+  }
+
+  bzero(&user, sizeof(struct user_t));
+  user.id = (unsigned int)Rf_asInteger(r_owner_restrict);
+  if (user.id > 0) {
+    wb = where(0, "owner_id", EQ, TYPE_ID, 1, user.id);
+
+    if (!modbFetchUserGroupIds(sconn, &modb, &user)) {
+      Rf_error("invalid user id\n");
+    }
+    if (user.n_groups > 0) {
+      for (idx = 0; idx < user.n_groups; idx++) {
+        if (modbFetchGroupMetadataIds(sconn, &modb, *(user.group_ids + idx), &ids, &n_ids) < 0) {
+          free(user.groups);
+          return R_NilValue;
+        }
+        for (m_idx = 0; m_idx < n_ids; m_idx++) {
+          if (wb_in == 0) {
+            modbTableName(&table, &table_len, &modb, METADATA_TABLE, STR_LEN(METADATA_TABLE));
+            wb_in = whereIn(0, table, "mdo_id", TYPE_ID, 0);
+            modbFreeTableName(&table);
+          }
+          setWhereValue(wb_in, TYPE_ID, 1, *(ids + m_idx));
+        }
+        free(ids);
+      }
+      free(user.groups);
+
+      if (wb_in != 0) {
+        wb = whereAnd(0, whereOr(wb, wb_in));
+      }
+    }
+  }
+
+  if (Rf_asLogical(r_with_deleted) == 0) {
+    wb = whereAnd(wb, where(0, "deleted", IS_NULL, TYPE_RAW, 0));
+  }
+
+  r_query_names = Rf_getAttrib(r_query, R_NamesSymbol);
+  for (i = 0; i < LENGTH(r_query); i++) {
+    col = Rf_translateCharUTF8(STRING_ELT(r_query_names, i));
+    r_tmp = VECTOR_ELT(r_query, i);
+    if (Rf_isNull(r_tmp)) {
+      wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+    } else {
+      switch(TYPEOF(r_tmp)) {
+        case LGLSXP:/* logical vectors */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_BOOL, 1, Rf_asLogical(r_tmp)));
+          break;
+        case INTSXP:/* integer vectors */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_INT32, 1, Rf_asInteger(r_tmp)));
+          break;
+        case REALSXP:/* real variables */
+          wb = whereAnd(wb, where(0, col, EQ, TYPE_DOUBLE, 1, Rf_asReal(r_tmp)));
+          break;
+        case STRSXP:/* string vectors */
+          r_tmp = STRING_ELT(r_tmp, 0);
+          if (r_tmp == R_NaString) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            tmp_str = Rf_translateCharUTF8(r_tmp);
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_STRING, 2, tmp_str, strlen(tmp_str)));
+          }
+          break;
+        case VECSXP:/* generic vectors */
+          break;
+        default:
+          break;
+          // Screwed if I know how to handle this...
+      }
+    }
+  }
+
+  if (modbMetadataQuery(sconn, &modb, wb, &metadata_list, &n_metadatas) <= 0) {
+    freeWhereBuilder(&wb);
+    return R_NilValue;
+  }
+  freeWhereBuilder(&wb);
+
+  r_metadatas = PROTECT(Rf_allocVector(VECSXP, (int)n_metadatas));
+  for (idx = 0; idx < n_metadatas; idx++) {
+    metadata = *(metadata_list + idx);
+
+    if (modbFetchMetadataOwner(sconn, &modb, metadata) < 0) {
+      freeMetadata(&metadata);
+      UNPROTECT(1 + (int)idx);
+      return R_NilValue;
+    }
+    if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) < 0) {
+      freeMetadataList(&metadata_list, n_metadatas);
+      UNPROTECT(1 + (int)idx);
+      return R_NilValue;
+    }
+//    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
+//      freeMetadataList(&metadata_list, n_metadatas);
+//      UNPROTECT(1 + (int)idx);
+//      return R_NilValue;
+//    }
+
+    SET_VECTOR_ELT(r_metadatas, (int)idx, PROTECT(metadataToR(metadata)));
+  }
+  freeMetadataList(&metadata_list, n_metadatas);
+
+  UNPROTECT((int)(1 + n_metadatas));
+  return r_metadatas;
+}
+
+SEXP rmodb_metaobjectIds(SEXP r_conn_ref, SEXP r_query, SEXP r_with_deleted)
+{
+  stored_conn *sconn;
+  modb_ref modb;
+  SEXP r_query_names;
+  SEXP r_tmp;
+  SEXP r_ids;
+  int i;
+  const char *col;
+  const char *tmp_str;
+  where_builder *wb = 0;
+  struct metadata_t *metadata;
+  struct metadata_t **metadata_list;
+  size_t n_metadatas;
+  size_t idx;
+
+  if ((sconn = getConnectionByRef(r_conn_ref)) == 0) {
+    Rf_error("invalid connection reference\n");
+  }
+
+  if (!modbFindUse(sconn, &modb)) {
+    Rf_error("invalid modb reference\n");
+  }
+
+  if (Rf_asLogical(r_with_deleted) == 0) {
+    wb = where(0, "deleted", IS_NULL, TYPE_RAW, 0);
+  }
+  r_query_names = Rf_getAttrib(r_query, R_NamesSymbol);
+  for (i = 0; i < LENGTH(r_query); i++) {
+    col = Rf_translateCharUTF8(STRING_ELT(r_query_names, i));
+    r_tmp = VECTOR_ELT(r_query, i);
+    if (Rf_isNull(r_tmp)) {
+      wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+    } else {
+      switch(TYPEOF(r_tmp)) {
+        case LGLSXP:/* logical vectors */
+          if (R_IsNA(Rf_asLogical(r_tmp))) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_BOOL, 1, Rf_asLogical(r_tmp)));
+          }
+          break;
+        case INTSXP:/* integer vectors */
+          if (R_IsNA(Rf_asInteger(r_tmp))) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_INT32, 1, Rf_asInteger(r_tmp)));
+          }
+          break;
+        case REALSXP:/* real variables */
+          if (R_IsNA(Rf_asReal(r_tmp))) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_DOUBLE, 1, Rf_asReal(r_tmp)));
+          }
+          break;
+        case STRSXP:/* string vectors */
+          r_tmp = STRING_ELT(r_tmp, 0);
+          if (r_tmp == R_NaString) {
+            wb = whereAnd(wb, where(0, col, IS_NULL, TYPE_RAW, 0));
+          } else {
+            tmp_str = Rf_translateCharUTF8(r_tmp);
+            wb = whereAnd(wb, where(0, col, EQ, TYPE_STRING, 2, tmp_str, strlen(tmp_str)));
+          }
+          break;
+        case VECSXP:/* generic vectors */
+          break;
+        default:
+          break;
+          // Screwed if I know how to handle this...
+      }
+    }
+  }
+
+  if (modbMetadataQuery(sconn, &modb, wb, &metadata_list, &n_metadatas) <= 0) {
+    freeWhereBuilder(&wb);
+    return R_NilValue;
+  }
+  freeWhereBuilder(&wb);
+
+  r_ids = PROTECT(Rf_allocVector(INTSXP, (int)n_metadatas));
+  for (idx = 0; idx < n_metadatas; idx++) {
+    metadata = *(metadata_list + idx);
+    SET_INTEGER_ELT(r_ids, (int)idx, (int)metadata->id);
+  }
+  freeMetadataList(&metadata_list, n_metadatas);
+
+  UNPROTECT(1);
+  return r_ids;
+}
 
 SEXP rmodb_metaobject(SEXP r_conn_ref, SEXP r_id)
 {
@@ -195,15 +583,15 @@ SEXP rmodb_metaobject(SEXP r_conn_ref, SEXP r_id)
     freeMetadata(&metadata);
     return R_NilValue;
   }
-  if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) <= 0) {
+  if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
-  if (modbFetchMetadataExtended(sconn, &modb, metadata) <= 0) {
+  if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
-  if (modbFetchMetadataObject(sconn, &modb, metadata) <= 0) {
+  if (modbFetchMetadataObject(sconn, &modb, metadata) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
@@ -234,15 +622,15 @@ SEXP rmodb_metadata(SEXP r_conn_ref, SEXP r_id)
   if (modbMetadataById(sconn, &modb, mo_id, &metadata) <= 0) {
     return R_NilValue;
   }
-  if (modbFetchMetadataOwner(sconn, &modb, metadata) <= 0) {
+  if (modbFetchMetadataOwner(sconn, &modb, metadata) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
-  if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) <= 0) {
+  if (modbFetchMetadataGroups(sconn, &modb, metadata, 0) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
-  if (modbFetchMetadataExtended(sconn, &modb, metadata) <= 0) {
+  if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
     freeMetadata(&metadata);
     return R_NilValue;
   }
@@ -320,11 +708,11 @@ SEXP rmodb_metaobjects(SEXP r_conn_ref, SEXP r_with_deleted)
       UNPROTECT(1 + (int)idx);
       return R_NilValue;
     }
-    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
-      freeMetadataList(&metadata_list, n_metadatas);
-      UNPROTECT(1 + (int)idx);
-      return R_NilValue;
-    }
+//    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
+//      freeMetadataList(&metadata_list, n_metadatas);
+//      UNPROTECT(1 + (int)idx);
+//      return R_NilValue;
+//    }
     if (modbFetchMetadataObject(sconn, &modb, metadata) < 0) {
       freeMetadataList(&metadata_list, n_metadatas);
       UNPROTECT(1 + (int)idx);
@@ -375,11 +763,11 @@ SEXP rmodb_metadatas(SEXP r_conn_ref, SEXP r_with_deleted)
       UNPROTECT(1 + (int)idx);
       return R_NilValue;
     }
-    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
-      freeMetadataList(&metadata_list, n_metadatas);
-      UNPROTECT(1 + (int)idx);
-      return R_NilValue;
-    }
+//    if (modbFetchMetadataExtended(sconn, &modb, metadata) < 0) {
+//      freeMetadataList(&metadata_list, n_metadatas);
+//      UNPROTECT(1 + (int)idx);
+//      return R_NilValue;
+//    }
 
     SET_VECTOR_ELT(r_metadatas, (int)idx, PROTECT(metadataToR(metadata)));
   }
@@ -485,20 +873,34 @@ SEXP rmodb_createMetaobject(SEXP r_conn_ref, SEXP r_id,
         switch(TYPEOF(r_tmp)) {
           case LGLSXP:/* logical vectors */
             ext_value->type = VTYPE_BOOL;
-            ext_value->value.bool = Rf_asLogical(r_tmp);
+            ext_value->value.boolVal = Rf_asLogical(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
             break;
           case INTSXP:/* integer vectors */
             ext_value->type = VTYPE_INT32;
             ext_value->value.int32 = Rf_asInteger(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
             break;
           case REALSXP:/* real variables */
             ext_value->type = VTYPE_DOUBLE;
             ext_value->value.dbl = Rf_asReal(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
             break;
           case STRSXP:/* string vectors */
             ext_value->type = VTYPE_STRING;
-            ext_value->value.str_c = Rf_translateCharUTF8(STRING_ELT(r_tmp, 0));
+            r_tmp = STRING_ELT(r_tmp, 0);
+            if (r_tmp == R_NaString) {
+              ext_value->is_null = 1;
+            } else {
+              ext_value->value.str_c = Rf_translateCharUTF8(r_tmp);
               ext_value->is_const = 1;
+            }
             break;
           case VECSXP:/* generic vectors */
             break;
@@ -519,9 +921,164 @@ SEXP rmodb_createMetaobject(SEXP r_conn_ref, SEXP r_id,
 
   return Rf_ScalarReal((double)metadata.id);
 }
-SEXP rmodb_updateMetaobject(SEXP r_conn_ref, SEXP r_id, SEXP r_metaobject)
+SEXP rmodb_updateMetaobject(SEXP r_conn_ref, SEXP r_id,
+                            SEXP r_metadata, SEXP r_object, SEXP r_extendedMeta)
 {
-  return R_NilValue;
+  stored_conn *sconn;
+  modb_ref modb;
+  struct metadata_t metadata;
+  struct object_t object;
+  struct meta_ext_t *metadata_ext;
+  struct meta_ext_value_t *ext_value;
+  struct r_memoryobject_t *memObj;
+  SEXP r_tmp, r_names;
+  int i;
+
+  if ((sconn = getConnectionByRef(r_conn_ref)) == 0) {
+    Rf_error("invalid connection reference\n");
+  }
+
+  if (!modbFindUse(sconn, &modb)) {
+    Rf_error("invalid modb reference\n");
+  }
+
+  memset(&metadata, 0, sizeof(struct metadata_t));
+  metadata.id = (unsigned int)Rf_asInteger(r_id);
+
+ if (!Rf_isNull(r_metadata) && TYPEOF(r_metadata) == VECSXP && LENGTH(r_metadata) == 1 && Rf_isNull(VECTOR_ELT(r_metadata, 0))) {
+    // Nothing to do here
+  } else {
+    r_tmp = R_listItem(r_metadata, "title");
+    if (r_tmp != R_NilValue) {
+      metadata.title_c = Rf_translateCharUTF8(STRING_ELT(r_tmp, 0));
+    }
+
+    r_tmp = R_listItem(r_metadata, "owner_id");
+    if (r_tmp != R_NilValue) {
+      metadata.owner_id = (unsigned int)Rf_asInteger(r_tmp);
+    }
+
+    r_tmp = R_listItem(r_metadata, "created_on");
+    if (r_tmp != R_NilValue) {
+      metadata.created_on = R_TimestampUnix(r_tmp);
+    }
+    r_tmp = R_listItem(r_metadata, "updated_on");
+    if (r_tmp != R_NilValue) {
+      metadata.updated_on = R_TimestampUnix(r_tmp);
+    }
+    r_tmp = R_listItem(r_metadata, "deleted_on");
+    if (r_tmp != R_NilValue) {
+      metadata.deleted_on = R_TimestampUnix(r_tmp);
+    }
+
+    if (!modbMetadataReplace(sconn, &modb, metadata.id, &metadata)) {
+      return Rf_ScalarLogical(FALSE);
+    }
+
+    r_tmp = R_listItem(r_metadata, "group_ids");
+    if (r_tmp != R_NilValue) {
+      if (LENGTH(r_tmp) == 1 && TYPEOF(r_tmp) != VECSXP) {
+        if (modbLink_Metadata_Group(
+              sconn, &modb, metadata.id,
+              (unsigned int)Rf_asInteger(r_tmp)) <= 0) {
+          return Rf_ScalarLogical(FALSE);
+        }
+      } else {
+        for (i = 0; i < LENGTH(r_tmp); i++) {
+          if (modbLink_Metadata_Group(
+                sconn, &modb, metadata.id,
+                (unsigned int)Rf_asInteger(VECTOR_ELT(r_tmp, i))) <= 0) {
+            return Rf_ScalarLogical(FALSE);
+          }
+        }
+      }
+    }
+  }
+
+  if (!Rf_isNull(r_object) && TYPEOF(r_object) == VECSXP && LENGTH(r_object) == 1 && Rf_isNull(VECTOR_ELT(r_object, 0))) {
+  } else {
+    memObj = robjectToMemory(r_object, R_MAGIC_XDR_V3);
+    object.id = metadata.id;
+    object.data_c = memObj->buf;
+    object.data_len = memObj->buf_size;
+    if (modbObjectUpdate(sconn, &modb, metadata.id, &object) <= 0) {
+      free(memObj->buf);
+      free(memObj);
+      return Rf_ScalarLogical(FALSE);
+    }
+    free(memObj->buf);
+    free(memObj);
+  }
+
+  if (!Rf_isNull(r_extendedMeta) && TYPEOF(r_extendedMeta) == VECSXP && LENGTH(r_extendedMeta) == 1 && Rf_isNull(VECTOR_ELT(r_extendedMeta, 0))) {
+
+  } else {
+    if ((metadata_ext = allocMetaExt()) == 0) {
+      return Rf_ScalarLogical(FALSE);
+    }
+    metadata_ext->id = metadata.id;
+    metadata_ext->n_values = (size_t)LENGTH(r_extendedMeta);
+    metadata_ext->values = allocMetaExtValues(metadata_ext->n_values, 1);
+    if (metadata_ext->values == 0) {
+      freeMetaExt(&metadata_ext);
+      return Rf_ScalarLogical(FALSE);
+    }
+    r_names = Rf_getAttrib(r_extendedMeta, R_NamesSymbol);
+    for (i = 0; i < LENGTH(r_extendedMeta); i++) {
+      ext_value = *(metadata_ext->values + i);
+      ext_value->key_c = Rf_translateCharUTF8(STRING_ELT(r_names, i));
+      r_tmp = VECTOR_ELT(r_extendedMeta, i);
+      if (Rf_isNull(r_tmp)) {
+        ext_value->type = VTYPE_RAW;
+        ext_value->is_null = 1;
+      } else {
+        switch(TYPEOF(r_tmp)) {
+          case LGLSXP:/* logical vectors */
+            ext_value->type = VTYPE_BOOL;
+            ext_value->value.boolVal = Rf_asLogical(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
+            break;
+          case INTSXP:/* integer vectors */
+            ext_value->type = VTYPE_INT32;
+            ext_value->value.int32 = Rf_asInteger(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
+            break;
+          case REALSXP:/* real variables */
+            ext_value->type = VTYPE_DOUBLE;
+            ext_value->value.dbl = Rf_asReal(r_tmp);
+            if (R_IsNA(Rf_asReal(r_tmp))) {
+              ext_value->is_null = 1;
+            }
+            break;
+          case STRSXP:/* string vectors */
+            ext_value->type = VTYPE_STRING;
+            r_tmp = STRING_ELT(r_tmp, 0);
+            if (r_tmp == R_NaString) {
+              ext_value->is_null = 1;
+            } else {
+              ext_value->value.str_c = Rf_translateCharUTF8(r_tmp);
+              ext_value->is_const = 1;
+            }
+            break;
+          case VECSXP:/* generic vectors */
+            break;
+          default:
+            break;
+            // Screwed if I know how to handle this...
+        }
+      }
+    }
+    if (modbMetaExtReplace(sconn, &modb, metadata.id, metadata_ext) <= 0) {
+      freeMetaExt(&metadata_ext);
+      return Rf_ScalarLogical(FALSE);
+    }
+  }
+
+  return Rf_ScalarLogical(TRUE);
 }
 SEXP rmodb_deleteMetaobject(SEXP r_conn_ref, SEXP r_id)
 {

src/R_modb_metaobjects.h

@@ -10,7 +10,10 @@ SEXP metadataToR(struct metadata_t *metadata);
 SEXP objectToR(struct object_t *object);
 SEXP metadataExtToR(struct meta_ext_t *ext);
 
-SEXP rmodb_metaobjectId(SEXP r_conn_ref, SEXP r_query);
+SEXP rmodb_metaobjectIds(SEXP r_conn_ref, SEXP r_query, SEXP with_deleted);
+SEXP rmodb_metaobjectQuery(SEXP r_conn_ref, SEXP r_query, SEXP r_with_deleted,
+                           SEXP r_owner_restrict);
+SEXP rmodb_metadataQuery(SEXP r_conn_ref, SEXP r_query, SEXP r_with_deleted, SEXP r_owner_restrict);
 
 SEXP rmodb_metaobject(SEXP r_conn_ref, SEXP r_id);
 SEXP rmodb_metadata(SEXP r_conn_ref, SEXP r_id);
@@ -21,7 +24,8 @@ SEXP rmodb_metadatas(SEXP r_conn_ref, SEXP r_with_deleted);
 
 SEXP rmodb_createMetaobject(SEXP r_conn_ref, SEXP r_id,
                             SEXP r_metadata, SEXP r_object, SEXP r_extendedMeta);
-SEXP rmodb_updateMetaobject(SEXP r_conn_ref, SEXP r_id, SEXP r_metaobject);
+SEXP rmodb_updateMetaobject(SEXP r_conn_ref, SEXP r_id,
+                            SEXP r_metadata, SEXP r_object, SEXP r_extendedMeta);
 SEXP rmodb_deleteMetaobject(SEXP r_conn_ref, SEXP r_id);
 
 

src/R_timestamp.c

@@ -89,8 +89,12 @@ SEXP R_TimestampExt(int64_t ts)
 
 int64_t R_TimestampUnix(SEXP r_ts)
 {
+  if (TYPEOF(r_ts) == REALSXP) {
+    return (int64_t)(Rf_asReal(r_ts) / 1);
+  } else {
     return (int64_t)(Rf_asReal(VECTOR_ELT(r_ts, 0)) / 1);
   }
+}
 
 int64_t R_TimestampExtUnix(SEXP r_ts)
 {

src/db_query.c

@@ -323,7 +323,7 @@ int64_t updateQuery(struct stored_conn_t *sconn,
 
   strbld_str(sb, "UPDATE ", 7);
   escapeTableName_sb(sb, table, table_len);
-  strbld_str(sb, " SET ", 4);
+  strbld_str(sb, " SET ", 5);
   strbld_str(sb, set, set_len);
   compileWhereBuilder_sb(sb, wb, 1);
 

src/db_timeout.c

@@ -19,13 +19,13 @@ int setTimeout(struct stored_conn_t *sconn, unsigned int timeout)
 {
   sconn->timeout = timeout;
 
-  if (mysql_optionsv(SQCONN(sconn), MYSQL_OPT_CONNECT_TIMEOUT, (void *)&timeout) != 0) {
+  if (mysql_options(SQCONN(sconn), MYSQL_OPT_CONNECT_TIMEOUT, (void *)&timeout) != 0) {
     return -1;
   }
-  if (mysql_optionsv(SQCONN(sconn), MYSQL_OPT_READ_TIMEOUT, (void *)&timeout) != 0) {
+  if (mysql_options(SQCONN(sconn), MYSQL_OPT_READ_TIMEOUT, (void *)&timeout) != 0) {
     return -1;
   }
-  if (mysql_optionsv(SQCONN(sconn), MYSQL_OPT_WRITE_TIMEOUT, (void *)&timeout) != 0) {
+  if (mysql_options(SQCONN(sconn), MYSQL_OPT_WRITE_TIMEOUT, (void *)&timeout) != 0) {
     return -1;
   }
 

src/db_value.c

@@ -52,10 +52,17 @@ void db_value_sbva(str_builder *sb, e_column_type type, uint32_t n_args, va_list
   int nchar;
 
   if (n_args == 0) {
+    if (type == TYPE_RAW) {
+      strbld_str(sb, "NULL", 4);
+    }
     return;
   }
 
   if (type == TYPE_RAW) {
+    if (n_args == 0) {
+      strbld_str(sb, "NULL", 4);
+      return;
+    }
     tmp_str = va_arg(args, char *);
     tmp_len = va_arg(args, size_t);
     strbld_str(sb, tmp_str, tmp_len);
@@ -63,8 +70,10 @@ void db_value_sbva(str_builder *sb, e_column_type type, uint32_t n_args, va_list
   }
 
   if (type == TYPE_TIMESTAMP) {
-    if (db_timestampString(va_arg(args, unsigned int), &tmp_str, &tmp_len) == 0) {
+    if (db_timestampString(va_arg(args, int64_t), &tmp_str, &tmp_len) != 0) {
+      strbld_char(sb, '\'');
       strbld_str(sb, tmp_str, tmp_len);
+      strbld_char(sb, '\'');
       free(tmp_str);
     }
     return;

src/initR.c

@@ -18,6 +18,8 @@ static const R_CallMethodDef callMethods[] = {
 
   {"rmodb_use", (DL_FUNC) &rmodb_use, 3},
 
+  {"rmodb_getLastQuery", (DL_FUNC) &rmodb_getLastQuery, 1},
+
 
   {"rmodb_groupId", (DL_FUNC) &rmodb_groupId, 2},
 
@@ -41,7 +43,9 @@ static const R_CallMethodDef callMethods[] = {
   {"rmodb_userRemoveGroup", (DL_FUNC) &rmodb_userRemoveGroup, 3},
 
 
-  {"rmodb_metaobjectId", (DL_FUNC) &rmodb_metaobjectId, 2},
+  {"rmodb_metaobjectIds", (DL_FUNC) &rmodb_metaobjectIds, 3},
+  {"rmodb_metaobjectQuery", (DL_FUNC) &rmodb_metaobjectQuery, 4},
+  {"rmodb_metadataQuery", (DL_FUNC) &rmodb_metadataQuery, 4},
 
   {"rmodb_metaobject", (DL_FUNC) &rmodb_metaobject, 2},
   {"rmodb_metadata", (DL_FUNC) &rmodb_metadata, 2},
@@ -51,7 +55,7 @@ static const R_CallMethodDef callMethods[] = {
   {"rmodb_metadatas", (DL_FUNC) &rmodb_metadatas, 2},
 
   {"rmodb_createMetaobject", (DL_FUNC) &rmodb_createMetaobject, 5},
-  {"rmodb_updateMetaobject", (DL_FUNC) &rmodb_updateMetaobject, 3},
+  {"rmodb_updateMetaobject", (DL_FUNC) &rmodb_updateMetaobject, 5},
   {"rmodb_deleteMetaobject", (DL_FUNC) &rmodb_deleteMetaobject, 2},
 
 

src/modb_database_p.c

@@ -272,7 +272,7 @@ uint64_t createMetaTable(stored_conn *sconn, modb_ref *modb)
         METADATA_TABLE, STR_LEN(METADATA_TABLE),
         "("
         "`mdo_id` INT UNSIGNED NOT NULL AUTO_INCREMENT, "
-        "`type` VARCHAR(255) NOT NULL, "
+//        "`type` VARCHAR(255) NOT NULL, "
         "`title` VARCHAR(255) NOT NULL, "
         "`owner_id` INT UNSIGNED NOT NULL, "
         "`created` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, "
@@ -289,7 +289,8 @@ uint64_t createObjectsTable(stored_conn *sconn, modb_ref *modb)
         OBJECTS_TABLE, STR_LEN(OBJECTS_TABLE),
         "("
         "`mdo_id` INT UNSIGNED NOT NULL, "
-        "`object` MEDIUMBLOB NULL, "
+        "`length` INT UNSIGNED NOT NULL, "
+        "`object` LONGBLOB NULL, "
         "PRIMARY KEY (`mdo_id`)"
         ")", 0
         );
@@ -303,7 +304,8 @@ uint64_t createMDOGroupsTable(stored_conn *sconn, modb_ref *modb)
         "`mdo_id` INT UNSIGNED NOT NULL, "
         "`group_id` INT UNSIGNED NOT NULL, "
         "INDEX(`mdo_id`), "
-        "INDEX(`group_id`)"
+        "INDEX(`group_id`), "
+        "UNIQUE(`mdo_id`, `group_id`)"
         ")", 0
         );
 }
@@ -351,7 +353,8 @@ uint64_t createUserGroupsTable(stored_conn *sconn, modb_ref *modb)
         "`user_id` INT UNSIGNED NOT NULL, "
         "`group_id` INT UNSIGNED NOT NULL, "
         "INDEX(`user_id`), "
-        "INDEX(`group_id`)"
+        "INDEX(`group_id`),"
+        "UNIQUE(`user_id`, `group_id`)"
         ")", 0
         );
 }
@@ -374,7 +377,7 @@ uint64_t createMetaExtTable(stored_conn *sconn, modb_ref *modb,
     strbld_str(sb, ", ", 2);
     columnCreateStr_sb(sb, *(col_data + c));
   }
-  strbld_str(sb, ", INDEX (`mdo_id`)"
+  strbld_str(sb, ", PRIMARY KEY (`mdo_id`)"
                  ")", 0);
   if (strbld_finalize_or_destroy(&sb, &table_def, &table_def_len) != 0) {
     return (uint64_t)-1;

src/modb_metadata.c

@@ -14,10 +14,12 @@
 int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
                             struct metadata_t ***metadata_list, size_t *n_metadatas)
 {
-  column_data *col_id, *col_type, *col_title, *col_owner_id,
+  column_data *col_id, *col_title, *col_owner_id,
       *col_created, *col_updated, *col_deleted;
   size_t n_rows, idx;
   struct metadata_t *metadata;
+  column_data **ext_cols;
+  column_data *col;
 
   n_rows = (*col_data)->n_values;
   if (n_rows == 0) {
@@ -25,16 +27,32 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
   }
 
   col_id = findColumnByName(col_data, n_cols, "mdo_id");
-  col_type = findColumnByName(col_data, n_cols, "type");
+  //col_type = findColumnByName(col_data, n_cols, "type");
   col_title = findColumnByName(col_data, n_cols, "title");
   col_owner_id = findColumnByName(col_data, n_cols, "owner_id");
   col_created = findColumnByName(col_data, n_cols, "created");
   col_updated = findColumnByName(col_data, n_cols, "updated");
   col_deleted = findColumnByName(col_data, n_cols, "deleted");
 
+  size_t n_ext_cols = 0;
+  ext_cols = malloc(n_cols * sizeof(column_data *));
+  if (ext_cols == 0) {
+    fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
+    return -1;
+  }
+  size_t tbl_len = STR_LEN(META_EXT_TABLE);
+  for (idx = 0; idx < n_cols; idx++) {
+    col = *(col_data + idx);
+    if (strncmp(col->table + (col->table_len - tbl_len), META_EXT_TABLE, tbl_len) == 0) {
+      *(ext_cols + n_ext_cols) = col;
+      n_ext_cols++;
+    }
+  }
+
   *metadata_list = (struct metadata_t **)malloc(sizeof(struct metadata_t *) * n_rows);
   if (*metadata_list == 0) {
     fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
+    free(ext_cols);
     return -errno;
   }
   memset(*metadata_list, 0, sizeof(struct metadata_t *) * n_rows);
@@ -43,19 +61,21 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
     metadata = allocMetadata();
     if (metadata == 0) {
       freeMetadataList(metadata_list, idx - 1);
+      free(ext_cols);
       return -1;
     }
 
     metadata->id = *(col_id->data.ptr_uint32 + idx);
 
-    if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) {
-      freeMetadataList(metadata_list, idx);
-      return -1;
-    }
-    metadata->type_c = metadata->type;
+//    if (!moveColumnStrPointer(col_type, idx, 1, &metadata->type, &metadata->type_len)) {
+//      freeMetadataList(metadata_list, idx);
+//      return -1;
+//    }
+//    metadata->type_c = metadata->type;
 
     if (!moveColumnStrPointer(col_title, idx, 1, &metadata->title, &metadata->title_len)) {
       freeMetadataList(metadata_list, idx);
+      free(ext_cols);
       return -1;
     }
     metadata->title_c = metadata->title;
@@ -70,8 +90,15 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
       metadata->deleted_on = *(col_deleted->data.ptr_int64 + idx);
     }
 
+    if (tableRowToMetaExt(ext_cols, n_ext_cols, idx, &metadata->ext) != 1) {
+      freeMetadataList(metadata_list, idx);
+      free(ext_cols);
+      return -1;
+    }
+
     *(*metadata_list + idx) = metadata;
   }
+  free(ext_cols);
 
   *n_metadatas = n_rows;
 
@@ -80,8 +107,8 @@ int tableRowsToMetadataList(column_data **col_data, size_t n_cols,
 int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
                         struct metadata_t ***metadata_list, size_t *n_metadatas)
 {
-  char *table;
-  size_t table_len;
+  char *table, *ext_table;
+  size_t table_len, ext_len;
   char *qry;
   size_t qry_len;
   uint64_t qry_ret;
@@ -97,14 +124,17 @@ int doMetadataListQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
     return -1;
   }
   modbTableName(&table, &table_len, modb, METADATA_TABLE, strlen(METADATA_TABLE));
+  modbTableName(&ext_table, &ext_len, modb, META_EXT_TABLE, strlen(META_EXT_TABLE));
 
   strbld_str(sb, "SELECT * FROM ", 0);
   escapeTableName_sb(sb, table, table_len);
+  joinStr_sb(sb, " LEFT", 5, 1, ext_table, ext_len, "mdo_id", 6, table, table_len, "mdo_id", 6);
   if (wb != 0) {
     compileWhereBuilder_sb(sb, wb, 0);
   }
   strbld_str(sb, " ORDER BY `updated` DESC, `created` DESC", 0);
 
+  modbFreeTableName(&ext_table);
   modbFreeTableName(&table);
   if (strbld_finalize_or_destroy(&sb, &qry, &qry_len) != 0) {
     return -1;
@@ -238,9 +268,13 @@ int modbMetadataById(stored_conn *sconn, modb_ref *modb, unsigned int id,
 {
   where_builder *wb = 0;
   int res;
+  char *table;
+  size_t table_len;
 
-  wb = where(0, "mdo_id", EQ, TYPE_ID, 1, id);
+  modbTableName(&table, &table_len, modb, METADATA_TABLE, strlen(METADATA_TABLE));
+  wb = where(table, "mdo_id", EQ, TYPE_ID, 1, id);
   res = doScalarMetadataListQuery(sconn, modb, wb, metadata);
+  free(table);
   freeWhereBuilder(&wb);
 
   return res;
@@ -296,6 +330,12 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g
   return res;
 }
 
+int modbMetadataQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
+                      struct metadata_t ***metadata_list, size_t *n_metadatas)
+{
+  return doMetadataListQuery(sconn, modb, wb, metadata_list, n_metadatas);
+}
+
 int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted,
                      struct metadata_t ***metadata_list, size_t *n_metadatas)
 {
@@ -323,9 +363,9 @@ unsigned int modbMetadataCreate(stored_conn *sconn, modb_ref *modb,
   size_t qry_len;
   uint64_t qry_ret;
 
-  if (metadata->type_c == 0) {
-    metadata->type_c = metadata->type;
-  }
+//  if (metadata->type_c == 0) {
+//    metadata->type_c = metadata->type;
+//  }
   if (metadata->title_c == 0) {
     metadata->title_c = metadata->title;
   }
@@ -337,10 +377,11 @@ unsigned int modbMetadataCreate(stored_conn *sconn, modb_ref *modb,
 
   strbld_str(sb, "INSERT INTO ", 0);
   escapeTableName_sb(sb, table, table_len);
-  strbld_str(sb, " (`mdo_id`, `type`, `title`, `owner_id`) VALUES (", 0);
+//  strbld_str(sb, " (`mdo_id`, `type`, `title`, `owner_id`) VALUES (", 0);
+  strbld_str(sb, " (`mdo_id`, `title`, `owner_id`) VALUES (", 0);
   db_value_sb(sb, TYPE_ID, 1, metadata->id);
-  strbld_char(sb, ',');
-  db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len);
+//  strbld_char(sb, ',');
+//  db_value_sb(sb, TYPE_STRING, 2, metadata->type_c, metadata->type_len);
   strbld_char(sb, ',');
   db_value_sb(sb, TYPE_STRING, 2, metadata->title_c, metadata->title_len);
   strbld_char(sb, ',');
@@ -370,9 +411,9 @@ int64_t modbMetadataReplace(stored_conn *sconn, modb_ref *modb, unsigned int id,
   size_t table_len, set_len;
   int64_t qry_ret;
 
-  if (metadata->type_c == 0) {
-    metadata->type_c = metadata->type;
-  }
+//  if (metadata->type_c == 0) {
+//    metadata->type_c = metadata->type;
+//  }
   if (metadata->title_c == 0) {
     metadata->title_c = metadata->title;
   }
@@ -380,18 +421,31 @@ int64_t modbMetadataReplace(stored_conn *sconn, modb_ref *modb, unsigned int id,
   if ((sb = strbld_create()) == 0) {
     return 0;
   }
+  columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, id);
   if (metadata->id != 0 && metadata->id != id) {
     strbld_char(sb, ',');
     columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, metadata->id);
   }
-  if (metadata->type_c != 0) {
-    strbld_char(sb, ',');
-    columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len);
-  }
+//  if (metadata->type_c != 0) {
+//    strbld_char(sb, ',');
+//    columnSetValueStr_sb(sb, "type", TYPE_STRING, 2, metadata->type_c, metadata->type_len);
+//  }
   if (metadata->title_c != 0) {
     strbld_char(sb, ',');
     columnSetValueStr_sb(sb, "title", TYPE_STRING, 2, metadata->title_c, metadata->title_len);
   }
+  if (metadata->created_on != 0) {
+    strbld_char(sb, ',');
+    columnSetValueStr_sb(sb, "created", TYPE_TIMESTAMP, 1, metadata->created_on);
+  }
+  if (metadata->updated_on != 0) {
+    strbld_char(sb, ',');
+    columnSetValueStr_sb(sb, "updated", TYPE_TIMESTAMP, 1, metadata->updated_on);
+  }
+  if (metadata->deleted_on != 0) {
+    strbld_char(sb, ',');
+    columnSetValueStr_sb(sb, "deleted", TYPE_TIMESTAMP, 1, metadata->deleted_on);
+  }
   if (metadata->owner != 0) {
     strbld_char(sb, ',');
     columnSetValueStr_sb(sb, "owner_id", TYPE_ID, 1, metadata->owner->id);

src/modb_metadata.h

@@ -9,9 +9,9 @@
 struct metadata_t {
   unsigned int id;
 
-  char *type;
-  const char *type_c;
-  size_t type_len;
+//  char *type;
+//  const char *type_c;
+//  size_t type_len;
 
   char *title;
   const char *title_c;
@@ -49,6 +49,9 @@ int modbMetadataListByGroupId(stored_conn *sconn, modb_ref *modb, unsigned int g
                               int with_deleted,
                               struct metadata_t ***metadata_list, size_t *n_metadatas);
 
+int modbMetadataQuery(stored_conn *sconn, modb_ref *modb, where_builder *wb,
+                      struct metadata_t ***metadata_list, size_t *n_metadatas);
+
 int modbMetadataList(stored_conn *sconn, modb_ref *modb, int with_deleted,
                      struct metadata_t ***metadata_list, size_t *n_metadatas);
 

src/modb_metadata_ext.c

@@ -8,39 +8,28 @@
 #include "modb_p.h"
 
 
-// ##### PRIVATE
-int tableRowsToMetaExtList(column_data **col_data, size_t n_cols,
-                            struct meta_ext_t ***ext_list, size_t *n_exts)
+// ##### PUBLIC
+int tableRowToMetaExt(column_data **col_data, size_t n_cols, size_t row_idx,
+                      struct meta_ext_t **ext_ptr)
 {
   column_data *col_id, *col;
-  size_t n_rows, r_idx, c_idx, v_idx;
+  size_t c_idx, v_idx;
   struct meta_ext_t *ext;
   struct meta_ext_value_t *ext_value;
 
-  n_rows = (*col_data)->n_values;
-  if (n_rows == 0) {
-    return 0;
-  }
-
   col_id = findColumnByName(col_data, n_cols, "mdo_id");
 
-  if ((*ext_list = allocMetaExtList(n_rows)) == 0) {
+  if ((ext = allocMetaExt()) == 0) {
     fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
     return -errno;
   }
+  *ext_ptr = ext;
 
-  for (r_idx = 0; r_idx < n_rows; r_idx++) {
-    if ((ext = allocMetaExt()) == 0) {
-      freeMetaExtList(ext_list, r_idx - 1);
-      return -1;
-    }
-    *((*ext_list) + r_idx) = ext;
-
-    ext->id = *(col_id->data.ptr_uint32 + r_idx);
+  ext->id = *(col_id->data.ptr_uint32 + row_idx);
 
   if (n_cols > 0) {
     if ((ext->values = allocMetaExtValues(n_cols - 1, 1)) == 0) {
-        freeMetaExtList(ext_list, r_idx);
+      freeMetaExt(ext_ptr);
       return -1;
     }
     ext->n_values = n_cols - 1;
@@ -55,7 +44,7 @@ int tableRowsToMetaExtList(column_data **col_data, size_t n_cols,
     ext_value = *(ext->values + v_idx);
 
     if (strmemcpy(col->name, col->name_len, &ext_value->key, &ext_value->key_len) != 0) {
-        freeMetaExtList(ext_list, r_idx);
+      freeMetaExt(ext_ptr);
       return -1;
     }
     ext_value->key_c = ext_value->key;
@@ -63,81 +52,128 @@ int tableRowsToMetaExtList(column_data **col_data, size_t n_cols,
     switch(col->type) {
       case TYPE_RAW:
         ext_value->type = VTYPE_RAW;
-          if (!moveColumnBlobPointer(col, r_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) {
-            freeMetaExtList(ext_list, r_idx);
+        break;
+      case TYPE_BOOL:
+        ext_value->type = VTYPE_BOOL;
+        break;
+      case TYPE_INT8:
+      case TYPE_UINT8:
+      case TYPE_INT16:
+      case TYPE_UINT16:
+      case TYPE_INT32:
+      case TYPE_FLOAT:
+        ext_value->type = VTYPE_INT32;
+        break;
+      case TYPE_UINT32:
+      case TYPE_INT64:
+      case TYPE_UINT64:
+      case TYPE_DOUBLE:
+        ext_value->type = VTYPE_DOUBLE;
+        break;
+      case TYPE_STRING:
+        ext_value->type = VTYPE_STRING;
+        break;
+      case TYPE_BLOB:
+        ext_value->type = VTYPE_RAW;
+        break;
+      case TYPE_TIMESTAMP:
+        ext_value->type = VTYPE_TIMESTAMP;
+        break;
+      case TYPE_ID:
+        ext_value->type = VTYPE_ID;
+        break;
+    }
+
+    if (columnRowIsNull(col, row_idx)) {
+      ext_value->is_null = 1;
+    } else {
+      switch(col->type) {
+        case TYPE_RAW:
+          if (!moveColumnBlobPointer(col, row_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) {
+            freeMetaExt(ext_ptr);
             return -1;
           }
           break;
         case TYPE_BOOL:
-          ext_value->type = VTYPE_BOOL;
-          ext_value->value.int32 = *(col->data.ptr_uint8 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_uint8 + row_idx);
           break;
         case TYPE_INT8:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.int32 = *(col->data.ptr_int8 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_int8 + row_idx);
           break;
         case TYPE_UINT8:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.int32 = *(col->data.ptr_uint8 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_uint8 + row_idx);
           break;
         case TYPE_INT16:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.int32 = *(col->data.ptr_int16 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_int16 + row_idx);
           break;
         case TYPE_UINT16:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.int32 = *(col->data.ptr_uint16 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_uint16 + row_idx);
           break;
         case TYPE_INT32:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.int32 = *(col->data.ptr_int32 + r_idx);
+          ext_value->value.int32 = *(col->data.ptr_int32 + row_idx);
           break;
         case TYPE_UINT32:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.dbl = (double)*(col->data.ptr_uint32 + r_idx);
+          ext_value->value.dbl = (double)*(col->data.ptr_uint32 + row_idx);
           break;
         case TYPE_INT64:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.dbl = (double)*(col->data.ptr_int64 + r_idx);
+          ext_value->value.dbl = (double)*(col->data.ptr_int64 + row_idx);
           break;
         case TYPE_UINT64:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.dbl = (double)*(col->data.ptr_uint64 + r_idx);
+          ext_value->value.dbl = (double)*(col->data.ptr_uint64 + row_idx);
           break;
         case TYPE_FLOAT:
-          ext_value->type = VTYPE_INT32;
-          ext_value->value.dbl = (double)*(col->data.ptr_float + r_idx);
+          ext_value->value.dbl = (double)*(col->data.ptr_float + row_idx);
           break;
         case TYPE_DOUBLE:
-          ext_value->type = VTYPE_DOUBLE;
-          ext_value->value.dbl = *(col->data.ptr_double + r_idx);
+          ext_value->value.dbl = *(col->data.ptr_double + row_idx);
           break;
         case TYPE_STRING:
-          ext_value->type = VTYPE_STRING;
-          if (!moveColumnStrPointer(col, r_idx, 1, &ext_value->value.str, &ext_value->value_len)) {
-            freeMetaExtList(ext_list, r_idx);
+          if (!moveColumnStrPointer(col, row_idx, 1, &ext_value->value.str, &ext_value->value_len)) {
+            freeMetaExt(ext_ptr);
             return -1;
           }
           break;
         case TYPE_BLOB:
-          ext_value->type = VTYPE_RAW;
-          if (!moveColumnBlobPointer(col, r_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) {
-            freeMetaExtList(ext_list, r_idx);
+          if (!moveColumnBlobPointer(col, row_idx, 1, (char **)&ext_value->value.raw, &ext_value->value_len)) {
+            freeMetaExt(ext_ptr);
             return -1;
           }
           break;
         case TYPE_TIMESTAMP:
-          ext_value->type = VTYPE_TIMESTAMP;
-          ext_value->value.ts = *(col->data.ptr_int64 + r_idx);
+          ext_value->value.ts = *(col->data.ptr_int64 + row_idx);
           break;
         case TYPE_ID:
-          ext_value->type = VTYPE_ID;
-          ext_value->value.id = *(col->data.ptr_uint32 + r_idx);
+          ext_value->value.id = *(col->data.ptr_uint32 + row_idx);
           break;
       }
     }
   }
 
+  return 1;
+}
+// ##### PRIVATE
+int tableRowsToMetaExtList(column_data **col_data, size_t n_cols,
+                            struct meta_ext_t ***ext_list, size_t *n_exts)
+{
+  size_t n_rows, r_idx;
+
+  n_rows = (*col_data)->n_values;
+  if (n_rows == 0) {
+    return 0;
+  }
+
+  if ((*ext_list = allocMetaExtList(n_rows)) == 0) {
+    fprintf(stderr, "[%d]malloc: (%d) %s\n", __LINE__, errno, strerror(errno));
+    return -errno;
+  }
+
+  for (r_idx = 0; r_idx < n_rows; r_idx++) {
+    if (tableRowToMetaExt(col_data, n_cols, r_idx, (*ext_list) + r_idx) != 1) {
+      freeMetaExtList(ext_list, r_idx);
+      return -1;
+    }
+  }
+
   *n_exts = n_rows;
 
   return 1;
@@ -424,12 +460,19 @@ int64_t modbMetaExtCreate(stored_conn *sconn, modb_ref *modb, struct meta_ext_t
   for (idx = 0; idx < meta_ext->n_values; idx++) {
     ext_value = *(meta_ext->values + idx);
     strbld_char(sb, ',');
+    if (ext_value->is_null) {
+      db_value_sb(sb, TYPE_RAW, 0);
+    } else {
       switch(ext_value->type) {
         case VTYPE_RAW:
+          if (ext_value->is_null) {
+            db_value_sb(sb, TYPE_RAW, 0);
+          } else {
             db_value_sb(sb, TYPE_RAW, 2, ext_value->value.raw, ext_value->value_len);
+          }
           break;
         case VTYPE_BOOL:
-        db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.bool);
+          db_value_sb(sb, TYPE_BOOL, 1, ext_value->value.boolVal);
           break;
         case VTYPE_INT32:
           db_value_sb(sb, TYPE_INT32, 1, ext_value->value.int32);
@@ -448,6 +491,7 @@ int64_t modbMetaExtCreate(stored_conn *sconn, modb_ref *modb, struct meta_ext_t
           break;
       }
     }
+  }
   strbld_char(sb, ')');
 
   modbFreeTableName(&table);
@@ -461,8 +505,6 @@ int64_t modbMetaExtCreate(stored_conn *sconn, modb_ref *modb, struct meta_ext_t
   return qry_ret == 0 ? meta_ext->id : 0;
 }
 int64_t modbMetaExtReplace(stored_conn *sconn, modb_ref *modb, unsigned int id,
-                          struct meta_ext_t *meta_ext);
-int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
                           struct meta_ext_t *meta_ext)
 {
   str_builder *sb;
@@ -480,6 +522,9 @@ int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
   for (idx = 0; idx < meta_ext->n_values; idx++) {
     ext_value = *(meta_ext->values + idx);
     strbld_char(sb, ',');
+    if (ext_value->is_null) {
+      columnSetValueStr_sb(sb, ext_value->key_c, TYPE_RAW, 0);
+    } else {
       switch(ext_value->type) {
         case VTYPE_RAW:
           columnSetValueStr_sb(
@@ -487,7 +532,7 @@ int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
                 );
           break;
         case VTYPE_BOOL:
-        columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.bool);
+          columnSetValueStr_sb(sb, ext_value->key_c, TYPE_BOOL, 1, ext_value->value.boolVal);
           break;
         case VTYPE_INT32:
           columnSetValueStr_sb(sb, ext_value->key_c, TYPE_INT32, 1, ext_value->value.int32);
@@ -508,6 +553,7 @@ int64_t modbMetaExtUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
           break;
       }
     }
+  }
 
   if (strbld_finalize_or_destroy(&sb, &set, &set_len) != 0) {
     return 0;

src/modb_metadata_ext.h

@@ -33,7 +33,7 @@ struct meta_ext_value_t {
 
   union {
     void *raw;
-    int bool;
+    int boolVal;
     int32_t int32;
     double dbl;
     char *str;
@@ -47,6 +47,10 @@ struct meta_ext_value_t {
   uint32_t is_const :1;
 };
 
+
+int tableRowToMetaExt(column_data **col_data, size_t n_cols, size_t row_idx,
+                      struct meta_ext_t **ext_ptr);
+
 struct meta_ext_t *allocMetaExt(void);
 void freeMetaExt(struct meta_ext_t **meta_ext);
 struct meta_ext_t **allocMetaExtList(size_t n_meta_ext_list);

src/modb_objects.c

@@ -233,9 +233,11 @@ int64_t modbObjectCreate(stored_conn *sconn, modb_ref *modb,
 
   strbld_str(sb, "INSERT INTO ", 0);
   escapeTableName_sb(sb, table, table_len);
-  strbld_str(sb, " (`mdo_id`, `object`) VALUES (", 0);
+  strbld_str(sb, " (`mdo_id`, `length`, `object`) VALUES (", 0);
   db_value_sb(sb, TYPE_ID, 1, object->id);
   strbld_char(sb, ',');
+  db_value_sb(sb, TYPE_UINT32, 1, object->data_len);
+  strbld_char(sb, ',');
   db_value_sb(sb, TYPE_BLOB, 2, object->data_c, object->data_len);
   strbld_char(sb, ')');
 
@@ -270,6 +272,8 @@ int64_t modbObjectUpdate(stored_conn *sconn, modb_ref *modb, unsigned int id,
     columnSetValueStr_sb(sb, "mdo_id", TYPE_ID, 1, object->id);
   }
   if (object->data_c != 0) {
+    strbld_char(sb, ',');
+    columnSetValueStr_sb(sb, "length", TYPE_UINT32, 1, object->data_len);
     strbld_char(sb, ',');
     columnSetValueStr_sb(sb, "object", TYPE_BLOB, 2, object->data_c, object->data_len);
   }