/* Object constructor */
static PHP_FUNCTION(php_midgard_view_constructor)
{
RETVAL_FALSE;
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
zval *zval_object = getThis();
GObject *gobject;
gobject = __php_gobject_ptr(zval_object);
if (!gobject) {
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardView *view = g_object_new(g_type_from_name(Z_OBJCE_P(zval_object)->name), NULL);
if (!view) {
php_midgard_error_exception_throw(mgd TSRMLS_CC);
return;
}
MGD_PHP_SET_GOBJECT(zval_object, view);
} else {
// we already have gobject injected
}
}
static PHP_METHOD(midgard_sql_query_constraint, __construct)
{
zval *z_column = NULL;
char *operator = NULL;
int op_length = 0;
zval *z_holder = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO",
&z_column, php_midgard_sql_query_column_class,
&operator, &op_length,
&z_holder, php_midgard_query_holder_class
) == FAILURE
) {
return;
}
MidgardSqlQueryColumn *column = MIDGARD_SQL_QUERY_COLUMN(__php_gobject_ptr(z_column));
MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder));
MidgardSqlQueryConstraint *constraint = midgard_sql_query_constraint_new(column, operator, holder);
if (!column) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), constraint);
}
static PHP_METHOD(midgard_sql_query_column, __construct)
{
zval *z_qprop = NULL;
char *name = NULL;
char *qualifier = NULL;
int name_length = 0;
int qualifier_length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|s",
&z_qprop, php_midgard_query_property_class,
&qualifier, &qualifier_length,
&name, &name_length
) == FAILURE
) {
return;
}
MidgardQueryProperty *queryproperty = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_qprop));
MidgardSqlQueryColumn *column = midgard_sql_query_column_new(queryproperty, qualifier, name);
if (!column) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQueryColumn");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), column);
}
// midgard_query_constraint
static PHP_METHOD(midgard_query_constraint, __construct)
{
char *operator = NULL;
int operator_len = 0;
zval *z_property = NULL;
zval *z_holder = NULL;
zval *z_storage = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OsO|O",
&z_property, php_midgard_query_property_class,
&operator, &operator_len,
&z_holder, php_midgard_query_holder_class,
&z_storage, php_midgard_query_storage_class
) == FAILURE
) {
return;
}
MidgardQueryProperty *property = MIDGARD_QUERY_PROPERTY(__php_gobject_ptr(z_property));
MidgardQueryHolder *holder = MIDGARD_QUERY_HOLDER(__php_gobject_ptr(z_holder));
MidgardQueryStorage *storage = NULL;
if (z_storage) {
storage = MIDGARD_QUERY_STORAGE(__php_gobject_ptr(z_storage));
}
MidgardQueryConstraint *constraint = midgard_query_constraint_new(property, operator, holder, storage);
if (!constraint) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), constraint);
}
/* Object constructor */
static PHP_METHOD(midgard_key_config_file, __construct)
{
RETVAL_FALSE;
zval *object = getThis();
char *path;
int path_length;
zval *ctx_object;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "os", &ctx_object, &path, &path_length) == FAILURE)
return;
GError *error = NULL;
MidgardKeyConfigFileContext *mkcf_ctx = (MidgardKeyConfigFileContext *) __php_gobject_ptr(ctx_object);
MidgardKeyConfigFile *mkcf = midgard_key_config_file_new(mkcf_ctx, path, &error);
if (error) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC,
error && error->message ? error->message : "Unknown reason");
g_clear_error (&error);
return;
}
MGD_PHP_SET_GOBJECT(object, mkcf);
}
static PHP_METHOD(midgard_sql_query_constraint, get_holder)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardSqlQueryConstraint *constraint = MIDGARD_SQL_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardQueryHolder *holder = midgard_sql_query_constraint_get_holder(constraint);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(holder)));
}
static PHP_METHOD(midgard_sql_query_select_data, get_connection)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis()));
MidgardConnection *mgd = midgard_query_selector_get_connection(selector);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(mgd)));
}
// midgard_query_constraint_group
static PHP_METHOD(midgard_query_constraint_group, __construct)
{
char *type = "AND";
int type_len = 3, num_varargs = 0;
zval ***varargs = NULL;
#if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &type, &type_len) == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
#else
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s*", &type, &type_len, &varargs, &num_varargs) == FAILURE) {
zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
#endif
MidgardQueryConstraintGroup *constraint_group = NULL;
if (num_varargs) {
MidgardQueryConstraintSimple **constraints = ecalloc(num_varargs, sizeof(MidgardQueryConstraintSimple *));
size_t i;
for (i = 0; i < num_varargs; i++) {
constraints[i] = MIDGARD_QUERY_CONSTRAINT_SIMPLE(__php_gobject_ptr(*varargs[i]));
}
efree(varargs);
constraint_group = midgard_query_constraint_group_new_with_constraints(type, constraints, num_varargs);
efree(constraints);
if (!constraint_group) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
} else {
constraint_group = midgard_query_constraint_group_new();
if (!constraint_group) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group");
return;
}
zend_bool result = midgard_query_constraint_group_set_group_type(constraint_group, type);
if (!result) {
g_object_unref(constraint_group);
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create constraint group: couldn't set type");
return;
}
}
MGD_PHP_SET_GOBJECT(getThis(), constraint_group);
}
/* Object constructor */
static PHP_METHOD(midgard_query_builder, __construct)
{
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
char *classname;
long classname_length;
zval *zval_object = getThis();
GObject *gobject;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) {
return;
}
zend_class_entry *ce = zend_fetch_class(classname, classname_length, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
if (ce == NULL) {
php_error(E_WARNING, "Didn't find %s class", classname);
php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);
return;
}
zend_class_entry *base_ce = php_midgard_get_baseclass_ptr(ce);
const gchar *g_base_class_name = php_class_name_to_g_class_name(base_ce->name);
GType classtype = g_type_from_name(g_base_class_name);
if (!g_type_is_a(classtype, MIDGARD_TYPE_DBOBJECT)) {
php_error(E_WARNING, "Expected %s derived class", g_type_name(MIDGARD_TYPE_DBOBJECT));
php_midgard_error_exception_force_throw(mgd, MGD_ERR_INVALID_OBJECT TSRMLS_CC);
return;
}
gobject = __php_gobject_ptr(zval_object);
if (!gobject) {
MidgardQueryBuilder *builder = midgard_query_builder_new(mgd, g_base_class_name);
if (!builder) {
php_midgard_error_exception_throw(mgd TSRMLS_CC);
return;
}
MGD_PHP_SET_GOBJECT(zval_object, builder);
} else {
// we already have gobject injected
}
php_midgard_gobject *php_gobject = __php_objstore_object(zval_object);
/* Set user defined class. We might need it when execute is invoked */
php_gobject->user_ce = ce;
php_gobject->user_class_name = (char *)ce->name;
}
static PHP_METHOD(midgard_query_row, get_object)
{
char *name;
int name_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE)
return;
MidgardQueryRow *row = MIDGARD_QUERY_ROW(__php_gobject_ptr(getThis()));
GObject *object = midgard_query_row_get_object(row, (const gchar *)name, NULL);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(object));
}
/* Object constructor */
PHP_METHOD(midgard_connection, __construct)
{
MidgardConnection *mgd = NULL;
if (MGDG(midgard_memory_debug)) {
php_printf("[%p] midgard_connection::__construct()\n", getThis());
}
if (zend_parse_parameters_none() == FAILURE)
return;
if (MGDG(midgard_http)) {
/* trying to reuse saved connection */
mgd = php_midgard_handle_lookup(&MGDG(midgard_global_holder), MGDG(all_configs) TSRMLS_CC);
if (mgd == NULL) {
/* @todo throw exception, instead */
php_error(E_ERROR, "Midgard handle-lookup failed (could not connect to database)");
return;
}
} else {
mgd = midgard_connection_new();
if (mgd == NULL) {
/* @todo throw exception, instead */
php_error(E_ERROR, "Failed to create underlying GObject instance");
return;
}
}
if (global_loghandler) {
if (MGDG(midgard_memory_debug)) {
php_printf("---> g_log_remove_handler(..., %d)\n", global_loghandler);
}
g_log_remove_handler(G_LOG_DOMAIN, global_loghandler);
}
// midgard_connection_set_loglevel(mgd, "warning", NULL);
global_loghandler = midgard_connection_get_loghandler(mgd);
if (MGDG(midgard_memory_debug)) {
php_printf("---> global_loghandler = %d\n", global_loghandler);
}
/* storing midgard_connection in object's store-structure */
MGD_PHP_SET_GOBJECT(getThis(), mgd);
// explicitly enable replication (to stay compatible with mjölnir)
midgard_connection_enable_replication(mgd, TRUE);
if (MGDG(midgard_memory_debug)) {
php_printf("[%p] <= midgard_connection::__construct()\n", getThis());
}
}
static PHP_METHOD(midgard_workspace, get_context)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardWorkspace *self = MIDGARD_WORKSPACE(__php_gobject_ptr(getThis()));
const MidgardWorkspaceContext *context = midgard_workspace_get_context(self);
if (!context)
RETURN_NULL();
object_init_ex(return_value, php_midgard_workspace_context_class);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(context)));
}
static PHP_METHOD(midgard_workspace_context, __construct)
{
zval *object = getThis();
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardWorkspaceContext *self = midgard_workspace_context_new();
if (!self) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create workspace context object");
return;
}
MGD_PHP_SET_GOBJECT(object, self);
}
static PHP_METHOD(midgard_query_constraint, get_storage)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQueryConstraint *constraint = MIDGARD_QUERY_CONSTRAINT(__php_gobject_ptr(getThis()));
MidgardQueryStorage *storage = midgard_query_constraint_get_storage(constraint);
if (!storage) {
return;
}
object_init_ex(return_value, php_midgard_query_storage_class);
MGD_PHP_SET_GOBJECT(return_value, storage);
// ^^^ no need to call constructor, as constructor doesn't do any magic here
}
/* Object constructor */
static PHP_METHOD(midgard_config, __construct)
{
RETVAL_FALSE;
zval *object = getThis();
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardConfig *config = midgard_config_new();
if (!config)
RETURN_FALSE;
MGD_PHP_SET_GOBJECT(object, config);
}
static PHP_METHOD(midgard_sql_query_select_data, __construct)
{
zval *z_mgd = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_mgd, php_midgard_connection_class) == FAILURE) {
return;
}
MidgardConnection *_mgd = MIDGARD_CONNECTION(__php_gobject_ptr(z_mgd));
MidgardSqlQuerySelectData *select = midgard_sql_query_select_data_new(_mgd);
if (!select) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create SqlQuerySelectData");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), select);
}
static PHP_METHOD(midgard_sql_query_select_data, get_query_result)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardQuerySelector *selector = MIDGARD_QUERY_SELECTOR(__php_gobject_ptr(getThis()));
GError *error = NULL;
MidgardQueryResult *result = midgard_query_selector_get_query_result(selector, &error);
if (!result) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to get result. %s", error && error->message ? error->message : "");
g_clear_error(&error);
return;
}
object_init_ex(return_value, php_midgard_sql_query_result_class);
MGD_PHP_SET_GOBJECT(return_value, g_object_ref(G_OBJECT(result)));
}
/* Object constructor */
static PHP_METHOD(midgard_query_storage, __construct)
{
char *classname;
int classname_length = 0;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &classname, &classname_length) == FAILURE) {
return;
}
const gchar *g_classname = php_class_name_to_g_class_name(classname);
MidgardQueryStorage *storage = midgard_query_storage_new(g_classname);
if (!storage) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Can not wrap this class in midgard_query_storage");
return;
}
MGD_PHP_SET_GOBJECT(getThis(), storage);
}
static PHP_METHOD(midgard_query_builder, execute)
{
RETVAL_FALSE;
MidgardConnection *mgd = mgd_handle(TSRMLS_C);
CHECK_MGD(mgd);
if (zend_parse_parameters_none() == FAILURE)
return;
_GET_BUILDER_OBJECT;
zend_class_entry *ce = php_gobject->user_ce;
if (ce == NULL) {
php_error(E_WARNING, "Query Builder instance not associated with any class");
return;
}
guint i, n_objects;
GObject **objects = midgard_query_builder_execute(builder, &n_objects);
array_init(return_value);
if (!objects)
return;
/* TODO: Should use iterator, instead, and create objects lazily */
/* Initialize zend objects for the same class which was used to initialize Query Builder */
for (i = 0; i < n_objects; i++) {
GObject *gobject = objects[i];
zval *zobject;
/* TODO: Simplify code below. If possible. */
MAKE_STD_ZVAL(zobject);
object_init_ex(zobject, ce); /* Initialize new object for which QB has been created for */
MGD_PHP_SET_GOBJECT(zobject, gobject); // inject our gobject
zend_call_method_with_0_params(&zobject, ce, &ce->constructor, "__construct", NULL); /* Call class constructor on given instance */
zend_hash_next_index_insert(HASH_OF(return_value), &zobject, sizeof(zval *), NULL);
}
if (objects)
g_free(objects);
}
static PHP_METHOD(midgard_object_reference, get_workspace)
{
if (zend_parse_parameters_none() == FAILURE)
return;
MidgardObjectReference *reference = MIDGARD_OBJECT_REFERENCE(__php_gobject_ptr(getThis()));
GError *error = NULL;
MidgardWorkspace *workspace = midgard_object_reference_get_workspace(reference, &error);
if (error) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC,
"Failed to get workspace. %s", error && error->message ? error->message : "Unknown reason");
return;
}
if (workspace == NULL)
RETURN_NULL();
object_init_ex(return_value, php_midgard_workspace_class);
MGD_PHP_SET_GOBJECT(return_value, G_OBJECT(workspace));
}
/* MidgardWorkspaceManager */
static PHP_METHOD(midgard_workspace_manager, __construct)
{
zval *z_mgd = NULL;
const gchar *g_class_name = g_type_name(MIDGARD_TYPE_CONNECTION);
zend_class_entry *ce = zend_fetch_class((char *)g_class_name, strlen(g_class_name), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &z_mgd, ce) == FAILURE) {
return;
}
zval *object = getThis();
MidgardWorkspaceManager *self = midgard_workspace_manager_new(MIDGARD_CONNECTION(__php_gobject_ptr(z_mgd)));
if (!self) {
zend_throw_exception_ex(ce_midgard_error_exception, 0 TSRMLS_CC, "Failed to create workspace object");
return;
}
MGD_PHP_SET_GOBJECT(object, self);
}
static PHP_METHOD(midgard_workspace_storage, get_workspace_by_name)
{
char *name;
int name_length;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_length) == FAILURE)
return;
MidgardWorkspaceStorage *self = MIDGARD_WORKSPACE_STORAGE(__php_gobject_ptr(getThis()));
MidgardWorkspaceStorage *workspace = midgard_workspace_storage_get_workspace_by_name(self, name);
if (!workspace)
RETURN_NULL();
if (MIDGARD_IS_WORKSPACE(self))
object_init_ex(return_value, php_midgard_workspace_class);
else
object_init_ex(return_value, php_midgard_workspace_context_class);
MGD_PHP_SET_GOBJECT(return_value, workspace);
}
static PHP_METHOD(midgard_object_reference, __construct)
{
char *id = NULL;
int id_length = 0;
char *name = NULL;
int name_length = 0;
zval *z_workspace = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sO",
&id, &id_length,
&name, &name_length,
&z_workspace, php_midgard_workspace_class
) == FAILURE) {
return;
}
MidgardWorkspace *workspace = NULL;
if (z_workspace != NULL)
workspace = MIDGARD_WORKSPACE(__php_gobject_ptr(z_workspace));
MidgardObjectReference *reference = midgard_object_reference_new (id, name, workspace);
MGD_PHP_SET_GOBJECT(getThis(), reference);
}
