9488c7aff7
* NEW: Automatic completion now displays hidden symbols if the class is part of the current project. * NEW: Support for *.tar.xz source archives. * NEW: Underscores are now allowed inside a class name. * BUG: Enabling or disabling tooltips in the option dialog does not crash anymore. [INTERPRETER] * NEW: Rename many virtual classes everywhere so that the documentation can easily extract the property name of the parent class from the virtual class name. For example, ".ApplicationArgs" is now ".Application.Args". git-svn-id: svn://localhost/gambas/trunk@4028 867c0c6c-44f3-4631-809d-bfa615b0a4ec
809 lines
17 KiB
C
809 lines
17 KiB
C
/***************************************************************************
|
|
|
|
CConnection.c
|
|
|
|
(c) 2000-2011 Benoît Minisini <gambas@users.sourceforge.net>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
MA 02110-1301, USA.
|
|
|
|
***************************************************************************/
|
|
|
|
#define __CCONNECTION_C
|
|
|
|
#include "main.h"
|
|
|
|
#include "CTable.h"
|
|
//#include "CView.h"
|
|
#include "CDatabase.h"
|
|
#include "CUser.h"
|
|
#include "CConnection.h"
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
Connection
|
|
|
|
***************************************************************************/
|
|
|
|
static CCONNECTION *_current = NULL;
|
|
|
|
static GB_SUBCOLLECTION_DESC _databases_desc =
|
|
{
|
|
".Connection.Databases",
|
|
(void *)CDATABASE_get,
|
|
(void *)CDATABASE_exist,
|
|
(void *)CDATABASE_list,
|
|
(void *)CDATABASE_release
|
|
};
|
|
|
|
static GB_SUBCOLLECTION_DESC _users_desc =
|
|
{
|
|
".Connection.Users",
|
|
(void *)CUSER_get,
|
|
(void *)CUSER_exist,
|
|
(void *)CUSER_list,
|
|
(void *)CUSER_release
|
|
};
|
|
|
|
static GB_SUBCOLLECTION_DESC _tables_desc =
|
|
{
|
|
".Connection.Tables",
|
|
(void *)CTABLE_get,
|
|
(void *)CTABLE_exist,
|
|
(void *)CTABLE_list,
|
|
(void *)CTABLE_release
|
|
};
|
|
|
|
/*static GB_SUBCOLLECTION_DESC _views_desc =
|
|
{
|
|
".ConnectionViews",
|
|
(void *)CVIEW_get,
|
|
(void *)CVIEW_exist,
|
|
(void *)CVIEW_list
|
|
};*/
|
|
|
|
|
|
|
|
static void open_connection(CCONNECTION *_object)
|
|
{
|
|
DB_Open(&THIS->desc, &THIS->driver, &THIS->db);
|
|
THIS->limit = 0;
|
|
THIS->trans = 0;
|
|
}
|
|
|
|
static bool check_opened(CCONNECTION *_object)
|
|
{
|
|
DB_CurrentDatabase = &THIS->db;
|
|
|
|
if (!THIS->db.handle)
|
|
open_connection(THIS);
|
|
|
|
if (!THIS->db.handle)
|
|
{
|
|
GB.Error("Connection is not opened");
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
#define CHECK_OPEN() \
|
|
if (check_opened(THIS)) \
|
|
return;
|
|
|
|
static int get_current(CCONNECTION **current)
|
|
{
|
|
if (*current == NULL)
|
|
{
|
|
if (_current == NULL)
|
|
{
|
|
GB.Error("No current connection");
|
|
return TRUE;
|
|
}
|
|
*current = _current;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
#define CHECK_DB() \
|
|
if (get_current((CCONNECTION **)(void *)&_object)) \
|
|
return;
|
|
|
|
static void close_connection(CCONNECTION *_object)
|
|
{
|
|
if (!THIS->db.handle)
|
|
return;
|
|
|
|
GB.Unref(POINTER(&THIS->databases));
|
|
THIS->databases = NULL;
|
|
GB.Unref(POINTER(&THIS->users));
|
|
THIS->users = NULL;
|
|
GB.Unref(POINTER(&THIS->tables));
|
|
THIS->tables = NULL;
|
|
|
|
THIS->driver->Close(&THIS->db);
|
|
GB.FreeString(&THIS->db.charset);
|
|
|
|
THIS->db.handle = NULL;
|
|
THIS->driver = NULL;
|
|
}
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_new, GB_STRING url)
|
|
|
|
char *url, *name, *p;
|
|
|
|
THIS->db.handle = NULL;
|
|
THIS->db.ignore_case = FALSE; // Now case is sensitive by default!
|
|
|
|
if (_current == NULL)
|
|
_current = THIS;
|
|
|
|
if (MISSING(url))
|
|
return;
|
|
|
|
url = GB.ToZeroString(ARG(url));
|
|
|
|
p = index(url, ':');
|
|
if (!p || p == url) goto __BAD_URL;
|
|
*p++ = 0;
|
|
if (p[0] != '/' || p[1] != '/') goto __BAD_URL;
|
|
p += 2;
|
|
|
|
THIS->desc.type = GB.NewZeroString(url);
|
|
url = p;
|
|
|
|
p = rindex(url, '/');
|
|
if (!p || p == url) goto __BAD_URL;
|
|
*p++ = 0;
|
|
|
|
name = p;
|
|
|
|
p = index(url, '@');
|
|
if (p)
|
|
{
|
|
if (p == url)
|
|
goto __BAD_URL;
|
|
*p = 0;
|
|
THIS->desc.user = GB.NewZeroString(url);
|
|
url = p + 1;
|
|
}
|
|
|
|
p = index(url, ':');
|
|
if (p)
|
|
{
|
|
*p = 0;
|
|
THIS->desc.port = GB.NewZeroString(p + 1);
|
|
}
|
|
|
|
THIS->desc.host = GB.NewZeroString(url);
|
|
|
|
THIS->desc.name = GB.NewZeroString(name);
|
|
|
|
__BAD_URL:
|
|
|
|
GB.Error("Malformed URL");
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_free)
|
|
|
|
close_connection(THIS);
|
|
|
|
if (_current == THIS)
|
|
_current = NULL;
|
|
|
|
GB.StoreString(NULL, &THIS->desc.type);
|
|
GB.StoreString(NULL, &THIS->desc.host);
|
|
GB.StoreString(NULL, &THIS->desc.user);
|
|
GB.StoreString(NULL, &THIS->desc.password);
|
|
GB.StoreString(NULL, &THIS->desc.name);
|
|
GB.StoreString(NULL, &THIS->desc.port);
|
|
GB.StoreString(NULL, &THIS->db.charset);
|
|
|
|
END_METHOD
|
|
|
|
|
|
#define IMPLEMENT(_prop) \
|
|
BEGIN_PROPERTY(CCONNECTION_##_prop) \
|
|
\
|
|
if (READ_PROPERTY) \
|
|
GB.ReturnString(THIS->desc._prop); \
|
|
else \
|
|
GB.StoreString(PROP(GB_STRING), &THIS->desc._prop); \
|
|
\
|
|
END_PROPERTY
|
|
|
|
IMPLEMENT(type)
|
|
IMPLEMENT(host)
|
|
IMPLEMENT(user)
|
|
IMPLEMENT(password)
|
|
IMPLEMENT(name)
|
|
IMPLEMENT(port)
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_version)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
GB.ReturnInteger(THIS->db.version);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_opened)
|
|
|
|
CHECK_DB();
|
|
|
|
GB.ReturnBoolean(THIS->db.handle != NULL);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_error)
|
|
|
|
CHECK_DB();
|
|
|
|
GB.ReturnInteger(THIS->db.error);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_open)
|
|
|
|
CHECK_DB();
|
|
|
|
if (THIS->db.handle)
|
|
{
|
|
GB.Error("Connection already opened");
|
|
return;
|
|
}
|
|
|
|
open_connection(THIS);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_close)
|
|
|
|
CHECK_DB();
|
|
|
|
close_connection(THIS);
|
|
|
|
END_METHOD
|
|
|
|
#if 0
|
|
BEGIN_PROPERTY(CCONNECTION_ignore_case)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
if (READ_PROPERTY)
|
|
GB.ReturnBoolean(THIS->db.ignore_case);
|
|
else
|
|
{
|
|
if (THIS->db.flags.no_case)
|
|
{
|
|
if (THIS->db.ignore_case)
|
|
GB.Error("This database driver cannot be case sensitive");
|
|
else
|
|
GB.Error("This database driver is always case sensitive");
|
|
return;
|
|
}
|
|
THIS->db.ignore_case = VPROP(GB_BOOLEAN);
|
|
}
|
|
|
|
END_PROPERTY
|
|
#endif
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_ignore_charset)
|
|
|
|
CHECK_DB();
|
|
|
|
if (READ_PROPERTY)
|
|
GB.ReturnBoolean(THIS->ignore_charset);
|
|
else
|
|
THIS->ignore_charset = VPROP(GB_BOOLEAN);
|
|
|
|
END_PROPERTY
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_begin)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
if (!THIS->db.flags.no_nest || THIS->trans == 0)
|
|
THIS->driver->Begin(&THIS->db);
|
|
THIS->trans++;
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_commit)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
if (THIS->trans == 0)
|
|
return;
|
|
|
|
THIS->trans--;
|
|
if (!THIS->db.flags.no_nest || THIS->trans == 0)
|
|
THIS->driver->Commit(&THIS->db);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD_VOID(CCONNECTION_rollback)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
if (THIS->trans == 0)
|
|
return;
|
|
|
|
THIS->trans--;
|
|
if (!THIS->db.flags.no_nest || THIS->trans == 0)
|
|
THIS->driver->Rollback(&THIS->db);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_limit, GB_INTEGER limit)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
THIS->limit = VARG(limit);
|
|
GB.ReturnObject(THIS);
|
|
|
|
END_PROPERTY
|
|
|
|
static char *_make_query_buffer;
|
|
static char *_make_query_original;
|
|
|
|
static void make_query_get_param(int index, char **str, int *len)
|
|
{
|
|
if (index == 1)
|
|
*str = _make_query_buffer;
|
|
else if (index == 2)
|
|
*str = _make_query_original;
|
|
|
|
*len = -1;
|
|
}
|
|
|
|
static char *make_query(CCONNECTION *_object, char *pattern, int len, int narg, GB_VALUE *arg)
|
|
{
|
|
char *query;
|
|
const char *keyword;
|
|
char buffer[32];
|
|
|
|
query = DB_MakeQuery(THIS->driver, pattern, len, narg, arg);
|
|
|
|
if (query && THIS->limit > 0 && strncasecmp(query, "SELECT ", 7) == 0)
|
|
{
|
|
keyword = THIS->db.limit.keyword;
|
|
if (!keyword)
|
|
keyword = "LIMIT";
|
|
|
|
snprintf(buffer, sizeof(buffer), "%s %d", keyword, THIS->limit);
|
|
|
|
_make_query_buffer = buffer;
|
|
_make_query_original = &query[7];
|
|
|
|
switch (THIS->db.limit.pos)
|
|
{
|
|
case DB_LIMIT_AT_BEGIN:
|
|
query = GB.SubstString("SELECT &1 &2", 0, make_query_get_param);
|
|
break;
|
|
|
|
case DB_LIMIT_AT_END:
|
|
default:
|
|
query = GB.SubstString("SELECT &2 &1", 0, make_query_get_param);
|
|
break;
|
|
}
|
|
|
|
THIS->limit = 0;
|
|
}
|
|
|
|
return query;
|
|
}
|
|
|
|
BEGIN_METHOD(CCONNECTION_exec, GB_STRING query; GB_VALUE param[0])
|
|
|
|
char *query;
|
|
CRESULT *result;
|
|
|
|
CHECK_DB();
|
|
|
|
CHECK_OPEN();
|
|
|
|
query = make_query(THIS, STRING(query), LENGTH(query), GB.NParam(), ARG(param[0]));
|
|
if (!query)
|
|
return;
|
|
|
|
result = DB_MakeResult(THIS, RESULT_FIND, NULL, query);
|
|
|
|
if (result)
|
|
GB.ReturnObject(result);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_create, GB_STRING table)
|
|
|
|
CRESULT *result;
|
|
char *table = GB.ToZeroString(ARG(table));
|
|
|
|
CHECK_DB();
|
|
|
|
CHECK_OPEN();
|
|
|
|
if (!table || !*table)
|
|
{
|
|
GB.Error("Void table name");
|
|
return;
|
|
}
|
|
|
|
result = DB_MakeResult(THIS, RESULT_CREATE, table, NULL);
|
|
|
|
if (result)
|
|
GB.ReturnObject(result);
|
|
else
|
|
GB.ReturnNull();
|
|
|
|
END_METHOD
|
|
|
|
|
|
static char *get_query(char *prefix, CCONNECTION *_object, char *table, int len_table, char *query, int len_query, GB_VALUE *arg)
|
|
{
|
|
if (!len_table)
|
|
{
|
|
GB.Error("Void table name");
|
|
return NULL;
|
|
}
|
|
|
|
q_init();
|
|
|
|
q_add(prefix);
|
|
q_add(" ");
|
|
q_add(THIS->driver->GetQuote());
|
|
q_add_length(table, len_table);
|
|
q_add(THIS->driver->GetQuote());
|
|
|
|
if (query && len_query > 0)
|
|
{
|
|
q_add(" ");
|
|
if (strncasecmp(query, "WHERE ", 6) && strncasecmp(query, "ORDER BY ", 9))
|
|
q_add("WHERE ");
|
|
q_add_length(query, len_query);
|
|
}
|
|
|
|
query = make_query(THIS, q_get(), q_length(), GB.NParam(), arg);
|
|
|
|
return query;
|
|
}
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_find, GB_STRING table; GB_STRING query; GB_VALUE param[0])
|
|
|
|
char *query;
|
|
CRESULT *result;
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
query = get_query("SELECT * FROM", THIS, STRING(table), LENGTH(table),
|
|
MISSING(query) ? NULL : STRING(query),
|
|
MISSING(query) ? 0 : LENGTH(query),
|
|
ARG(param[0]));
|
|
|
|
if (!query)
|
|
return;
|
|
|
|
result = DB_MakeResult(THIS, RESULT_FIND, NULL, query);
|
|
|
|
if (result)
|
|
GB.ReturnObject(result);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_delete, GB_STRING table; GB_STRING query; GB_VALUE param[0])
|
|
|
|
char *query;
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
query = get_query("DELETE FROM", THIS, STRING(table), LENGTH(table),
|
|
MISSING(query) ? NULL : STRING(query),
|
|
MISSING(query) ? 0 : LENGTH(query),
|
|
ARG(param[0]));
|
|
|
|
if (!query)
|
|
return;
|
|
|
|
DB_MakeResult(THIS, RESULT_DELETE, NULL, query);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_edit, GB_STRING table; GB_STRING query; GB_VALUE param[0])
|
|
|
|
char *query;
|
|
CRESULT *result;
|
|
/*char *table = GB.ToZeroString(ARG(table));*/
|
|
|
|
CHECK_DB();
|
|
|
|
CHECK_OPEN();
|
|
|
|
/*if (check_table(THIS, table, TRUE))
|
|
return;*/
|
|
|
|
query = get_query("SELECT * FROM", THIS, STRING(table), LENGTH(table),
|
|
MISSING(query) ? NULL : STRING(query),
|
|
MISSING(query) ? 0 : LENGTH(query),
|
|
ARG(param[0]));
|
|
|
|
if (!query)
|
|
return;
|
|
|
|
result = DB_MakeResult(THIS, RESULT_EDIT, GB.ToZeroString(ARG(table)), query);
|
|
|
|
if (result)
|
|
GB.ReturnObject(result);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_quote, GB_STRING name; GB_BOOLEAN is_table)
|
|
|
|
char *name = STRING(name);
|
|
int len = LENGTH(name);
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
if (VARGOPT(is_table, FALSE) && THIS->db.flags.schema)
|
|
GB.ReturnNewZeroString(DB_GetQuotedTable(THIS->driver, &THIS->db, GB.ToZeroString(ARG(name))));
|
|
else
|
|
{
|
|
q_init();
|
|
q_add(THIS->driver->GetQuote());
|
|
q_add_length(name, len);
|
|
q_add(THIS->driver->GetQuote());
|
|
GB.ReturnString(q_get());
|
|
}
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_format_blob, GB_STRING data)
|
|
|
|
DB_BLOB blob;
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
blob.data = STRING(data);
|
|
blob.length = LENGTH(data);
|
|
|
|
q_init();
|
|
DB_CurrentDatabase = &THIS->db;
|
|
(*THIS->driver->FormatBlob)(&blob, q_add_length);
|
|
GB.ReturnString(q_get());
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_METHOD(CCONNECTION_subst, GB_STRING query; GB_VALUE param[0])
|
|
|
|
char *query;
|
|
|
|
CHECK_DB();
|
|
|
|
CHECK_OPEN();
|
|
|
|
query = make_query(THIS, STRING(query), LENGTH(query), GB.NParam(), ARG(param[0]));
|
|
|
|
if (!query)
|
|
return;
|
|
|
|
GB.ReturnString(query);
|
|
|
|
END_METHOD
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_current)
|
|
|
|
if (READ_PROPERTY)
|
|
GB.ReturnObject(_current);
|
|
else
|
|
_current = (CCONNECTION *)VPROP(GB_OBJECT);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_charset)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
if (THIS->db.charset)
|
|
GB.ReturnString(THIS->db.charset);
|
|
else
|
|
GB.ReturnConstZeroString("ASCII");
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_databases)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
GB.SubCollection.New(&THIS->databases, &_databases_desc, THIS);
|
|
GB.ReturnObject(THIS->databases);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_users)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
GB.SubCollection.New(&THIS->users, &_users_desc, THIS);
|
|
GB.ReturnObject(THIS->users);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_tables)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
GB.SubCollection.New(&THIS->tables, &_tables_desc, THIS);
|
|
GB.ReturnObject(THIS->tables);
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
/*BEGIN_PROPERTY(CCONNECTION_views)
|
|
|
|
CHECK_DB();
|
|
CHECK_OPEN();
|
|
|
|
GB.SubCollection.New(&THIS->views, &_views_desc, THIS);
|
|
GB.ReturnObject(THIS->views);
|
|
|
|
END_PROPERTY*/
|
|
|
|
|
|
BEGIN_PROPERTY(CCONNECTION_debug)
|
|
|
|
if (READ_PROPERTY)
|
|
GB.ReturnBoolean(DB_IsDebug());
|
|
else
|
|
DB_SetDebug(VPROP(GB_BOOLEAN));
|
|
|
|
END_PROPERTY
|
|
|
|
|
|
GB_DESC CConnectionDesc[] =
|
|
{
|
|
GB_DECLARE("Connection", sizeof(CCONNECTION)),
|
|
|
|
GB_METHOD("_new", NULL, CCONNECTION_new, "[(DatabaseURL)s]"),
|
|
GB_METHOD("_free", NULL, CCONNECTION_free, NULL),
|
|
|
|
GB_PROPERTY("Type", "s", CCONNECTION_type),
|
|
GB_PROPERTY("Host", "s", CCONNECTION_host),
|
|
GB_PROPERTY("Login", "s", CCONNECTION_user),
|
|
GB_PROPERTY("User", "s", CCONNECTION_user),
|
|
GB_PROPERTY("Password", "s", CCONNECTION_password),
|
|
GB_PROPERTY("Name", "s", CCONNECTION_name),
|
|
GB_PROPERTY("Port", "s", CCONNECTION_port),
|
|
GB_PROPERTY_READ("Charset", "s", CCONNECTION_charset),
|
|
GB_PROPERTY_READ("Version", "i", CCONNECTION_version),
|
|
GB_PROPERTY_READ("Opened", "b", CCONNECTION_opened),
|
|
GB_PROPERTY_READ("Error", "i", CCONNECTION_error),
|
|
GB_PROPERTY("IgnoreCharset", "b", CCONNECTION_ignore_charset),
|
|
|
|
GB_METHOD("Open", NULL, CCONNECTION_open, NULL),
|
|
GB_METHOD("Close", NULL, CCONNECTION_close, NULL),
|
|
|
|
GB_METHOD("Limit", "Connection", CCONNECTION_limit, "(Limit)i"),
|
|
GB_METHOD("Exec", "Result", CCONNECTION_exec, "(Request)s(Arguments)."),
|
|
GB_METHOD("Create", "Result", CCONNECTION_create, "(Table)s"),
|
|
GB_METHOD("Find", "Result", CCONNECTION_find, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_METHOD("Edit", "Result", CCONNECTION_edit, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_METHOD("Delete", NULL, CCONNECTION_delete, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_METHOD("Subst", "s", CCONNECTION_subst, "(Format)s(Arguments)."),
|
|
|
|
GB_METHOD("Begin", NULL, CCONNECTION_begin, NULL),
|
|
GB_METHOD("Commit", NULL, CCONNECTION_commit, NULL),
|
|
GB_METHOD("Rollback", NULL, CCONNECTION_rollback, NULL),
|
|
|
|
GB_METHOD("Quote", "s", CCONNECTION_quote, "(Name)s[(Table)b]"),
|
|
GB_METHOD("FormatBlob", "s", CCONNECTION_format_blob, "(Data)s"),
|
|
|
|
GB_PROPERTY("Tables", ".Connection.Tables", CCONNECTION_tables),
|
|
GB_PROPERTY("Databases", ".Connection.Databases", CCONNECTION_databases),
|
|
GB_PROPERTY("Users", ".Connection.Users", CCONNECTION_users),
|
|
//GB_PROPERTY("Views", ".ConnectionViews", CCONNECTION_views),
|
|
|
|
GB_CONSTANT("_Properties", "s", "Type,Host,Login,Password,Name,Port"),
|
|
|
|
GB_END_DECLARE
|
|
};
|
|
|
|
|
|
GB_DESC CDBDesc[] =
|
|
{
|
|
GB_DECLARE("DB", 0), GB_VIRTUAL_CLASS(),
|
|
|
|
GB_CONSTANT("Boolean", "i", GB_T_BOOLEAN),
|
|
GB_CONSTANT("Integer", "i", GB_T_INTEGER),
|
|
GB_CONSTANT("Long", "i", GB_T_LONG),
|
|
GB_CONSTANT("Float", "i", GB_T_FLOAT),
|
|
GB_CONSTANT("Date", "i", GB_T_DATE),
|
|
GB_CONSTANT("String", "i", GB_T_STRING),
|
|
GB_CONSTANT("Serial", "i", DB_T_SERIAL),
|
|
GB_CONSTANT("Blob", "i", DB_T_BLOB),
|
|
|
|
GB_STATIC_PROPERTY("Current", "Connection", CCONNECTION_current),
|
|
|
|
GB_STATIC_METHOD("Open", NULL, CCONNECTION_open, NULL),
|
|
GB_STATIC_METHOD("Close", NULL, CCONNECTION_close, NULL),
|
|
|
|
GB_STATIC_PROPERTY_READ("Charset", "s", CCONNECTION_charset),
|
|
GB_STATIC_PROPERTY_READ("Version", "i", CCONNECTION_version),
|
|
GB_STATIC_PROPERTY_READ("Opened", "b", CCONNECTION_opened),
|
|
GB_STATIC_PROPERTY_READ("Error", "i", CCONNECTION_error),
|
|
GB_STATIC_PROPERTY("IgnoreCharset", "b", CCONNECTION_ignore_charset),
|
|
|
|
GB_STATIC_PROPERTY("Debug", "b", CCONNECTION_debug),
|
|
|
|
GB_STATIC_METHOD("Limit", "Connection", CCONNECTION_limit, "(Limit)i"),
|
|
GB_STATIC_METHOD("Exec", "Result", CCONNECTION_exec, "(Request)s(Arguments)."),
|
|
GB_STATIC_METHOD("Create", "Result", CCONNECTION_create, "(Table)s"),
|
|
GB_STATIC_METHOD("Find", "Result", CCONNECTION_find, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_STATIC_METHOD("Edit", "Result", CCONNECTION_edit, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_STATIC_METHOD("Delete", NULL, CCONNECTION_delete, "(Table)s[(Request)s(Arguments).]"),
|
|
GB_STATIC_METHOD("Subst", "s", CCONNECTION_subst, "(Format)s(Arguments)."),
|
|
|
|
GB_STATIC_METHOD("Begin", NULL, CCONNECTION_begin, NULL),
|
|
GB_STATIC_METHOD("Commit", NULL, CCONNECTION_commit, NULL),
|
|
GB_STATIC_METHOD("Rollback", NULL, CCONNECTION_rollback, NULL),
|
|
|
|
GB_STATIC_METHOD("Quote", "s", CCONNECTION_quote, "(Name)s[(Table)b]"),
|
|
GB_STATIC_METHOD("FormatBlob", "s", CCONNECTION_format_blob, "(Data)s"),
|
|
|
|
GB_STATIC_PROPERTY("Tables", ".Connection.Tables", CCONNECTION_tables),
|
|
//GB_STATIC_PROPERTY("Views", ".ConnectionViews", CCONNECTION_views),
|
|
GB_STATIC_PROPERTY("Databases", ".Connection.Databases", CCONNECTION_databases),
|
|
GB_STATIC_PROPERTY("Users", ".Connection.Users", CCONNECTION_users),
|
|
|
|
GB_END_DECLARE
|
|
};
|
|
|
|
|