839 lines
27 KiB
C
839 lines
27 KiB
C
/*************************************************************************
|
|
* *
|
|
* YAP Prolog *
|
|
* *
|
|
* Yap Prolog was developed at NCCUP - Universidade do Porto *
|
|
* *
|
|
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
|
|
* *
|
|
**************************************************************************
|
|
* *
|
|
* File: myddas_odbc.c *
|
|
* Last rev: 22/03/05 *
|
|
* mods: *
|
|
* comments: Predicates for comunicating with ODBC drivers *
|
|
* *
|
|
*************************************************************************/
|
|
|
|
#if defined MYDDAS_ODBC
|
|
|
|
#if !defined(ODBCVER)
|
|
typedef void *SQLHDBC;
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "Yap.h"
|
|
#include "Yatom.h"
|
|
#include "myddas.h"
|
|
#include "../myddas_util.h"
|
|
#include "cut_c.h"
|
|
#include <sql.h>
|
|
#include <sqlucode.h>
|
|
|
|
/* Return enviromment identifier*/
|
|
SQLHENV myddas_util_get_odbc_enviromment(SQLHDBC);
|
|
|
|
static Int null_id = 0;
|
|
|
|
static Int c_db_odbc_connect(USES_REGS1);
|
|
static Int c_db_odbc_disconnect(USES_REGS1);
|
|
static Int c_db_odbc_number_of_fields(USES_REGS1);
|
|
static Int c_db_odbc_get_attributes_types(USES_REGS1);
|
|
static Int c_db_odbc_query(USES_REGS1);
|
|
static Int c_db_odbc_row(USES_REGS1);
|
|
static Int c_db_odbc_row_cut(USES_REGS1);
|
|
static Int c_db_odbc_get_fields_properties(USES_REGS1);
|
|
static Int c_db_odbc_number_of_fields_in_query(USES_REGS1);
|
|
|
|
static int odbc_error(SQLSMALLINT type, SQLHANDLE hdbc, char *msg,
|
|
char *print) {
|
|
SQLCHAR SqlState[6], Msg[SQL_MAX_MESSAGE_LENGTH];
|
|
SQLINTEGER NativeError;
|
|
SQLSMALLINT i = 1, MsgLen;
|
|
|
|
SQLGetDiagRec(type, hdbc, i, SqlState, &NativeError, Msg, sizeof(Msg),
|
|
&MsgLen);
|
|
fprintf(stderr,
|
|
"%% error in SQLConnect: %s got error code %s\n%% SQL Message: %s\n",
|
|
print, SqlState, Msg);
|
|
return FALSE;
|
|
}
|
|
|
|
static int SQLALLOCHANDLE(SQLSMALLINT HandleType, SQLHANDLE hdbc,
|
|
SQLHANDLE *outHandle, char *print) {
|
|
SQLRETURN retcode;
|
|
|
|
retcode = SQLAllocHandle(HandleType, hdbc, outHandle);
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
|
|
return odbc_error(HandleType, hdbc, "SQLAllocHandle(ENV)", print);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLSETENVATTR(SQLHENV henv, SQLINTEGER att, SQLPOINTER p,
|
|
SQLINTEGER len, char *print) {
|
|
SQLRETURN retcode;
|
|
|
|
retcode = SQLSetEnvAttr(henv, att, p, len);
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
|
|
return odbc_error(SQL_HANDLE_ENV, henv, "SQLSetEnvAttr", print);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLCONNECT(SQLHDBC hdbc, SQLCHAR *driver, SQLCHAR *user,
|
|
SQLCHAR *password, char *print) {
|
|
SQLRETURN retcode;
|
|
|
|
retcode = SQLConnect(hdbc, driver, SQL_NTS, user, SQL_NTS, password, SQL_NTS);
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_DBC, hdbc, "SQLConnect", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLEXECDIRECT(SQLHSTMT StatementHandle, SQLCHAR *StatementText,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLExecDirect(StatementHandle, StatementText, SQL_NTS);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, StatementHandle, "SQLExecDirect", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLDESCRIBECOL(SQLHSTMT sth, SQLSMALLINT colno, SQLCHAR *colname,
|
|
SQLSMALLINT bflength, SQLSMALLINT *nmlengthp,
|
|
SQLSMALLINT *dtptr, SQLULEN *colszptr,
|
|
SQLSMALLINT *ddptr, SQLSMALLINT *nullableptr,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLDescribeCol(sth, colno, colname, bflength, nmlengthp, dtptr,
|
|
colszptr, ddptr, nullableptr);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, sth, "SQLDescribeCol", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLSETCONNECTATTR(SQLHDBC hdbc, SQLINTEGER attr, SQLPOINTER vptr,
|
|
SQLINTEGER slen, char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLSetConnectAttr(hdbc, attr, vptr, slen);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, hdbc, "SQLSetConnectAttr", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLBINDCOL(SQLHSTMT sthandle, SQLUSMALLINT colno, SQLSMALLINT tt,
|
|
SQLPOINTER tvptr, SQLLEN blen, SQLLEN *strl,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLBindCol(sthandle, colno, tt, tvptr, blen, strl);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, sthandle, "SQLBindCol", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLNUMRESULTCOLS(SQLHSTMT sthandle, SQLSMALLINT *ncols,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLNumResultCols(sthandle, ncols);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, sthandle, "SQLNumResultCols", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLCLOSECURSOR(SQLHSTMT sthandle, char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLCloseCursor(sthandle);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, sthandle, "SQLCloseCursor", print);
|
|
return TRUE;
|
|
}
|
|
|
|
#define SQLFETCH(A, print) \
|
|
{ \
|
|
SQLRETURN retcode; \
|
|
retcode = SQLFetch(A); \
|
|
if (retcode == SQL_NO_DATA) \
|
|
break; \
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) { \
|
|
printf("Error in SQLFETCH: %s\n", print); \
|
|
return FALSE; \
|
|
} \
|
|
}
|
|
|
|
static int SQLGETDATA(SQLHSTMT sthandle, SQLUSMALLINT Col_or_Param_Num,
|
|
SQLSMALLINT TargetType, SQLPOINTER TargetValuePtr,
|
|
SQLLEN BufferLength, SQLLEN *StrLen_or_IndPtr,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLGetData(sthandle, Col_or_Param_Num, TargetType, TargetValuePtr,
|
|
BufferLength, StrLen_or_IndPtr);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, sthandle, "SQLGetData", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLDISCONNECT(SQLHSTMT sthandle, char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLDisconnect(sthandle);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_DBC, sthandle, "SQLDisconnect", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLFREEHANDLE(SQLSMALLINT HandleType, SQLHANDLE Handle,
|
|
char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLFreeHandle(HandleType, Handle);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(HandleType, Handle, "SQLDisconnect", print);
|
|
return TRUE;
|
|
}
|
|
|
|
static int SQLPRIMARYKEYS(SQLHSTMT StatementHandle, SQLCHAR *CatalogName,
|
|
SQLSMALLINT NameLength1, SQLCHAR *SchemaName,
|
|
SQLSMALLINT NameLength2, SQLCHAR *TableName,
|
|
SQLSMALLINT NameLength3, char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLPrimaryKeys(StatementHandle, CatalogName, NameLength1,
|
|
SchemaName, NameLength2, TableName, NameLength3);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, StatementHandle, "SQLPrimaryKeys",
|
|
print);
|
|
return TRUE;
|
|
}
|
|
|
|
/********************************************
|
|
NOT IN USE
|
|
static int SQLGETTYPEINFO(SQLHSTMT StatementHandle,
|
|
SQLSMALLINT DataType,
|
|
char * print)
|
|
{
|
|
SQLRETURN retcode;
|
|
retcode = SQLGetTypeInfo(StatementHandle, DataType);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, StatementHandle, "SQLGetTypeInfo",
|
|
print);
|
|
return TRUE;
|
|
}
|
|
********************************************/
|
|
|
|
static int SQLCOLATTRIBUTE(SQLHSTMT StatementHandle, SQLUSMALLINT ColumnNumber,
|
|
SQLUSMALLINT FieldIdentifier,
|
|
SQLPOINTER CharacterAttributePtr,
|
|
SQLSMALLINT BufferLength,
|
|
SQLSMALLINT *StringLengthPtr,
|
|
SQLLEN *NumericAttributePtr, char *print) {
|
|
SQLRETURN retcode;
|
|
retcode = SQLColAttribute(StatementHandle, ColumnNumber, FieldIdentifier,
|
|
CharacterAttributePtr, BufferLength,
|
|
StringLengthPtr, NumericAttributePtr);
|
|
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
|
|
return odbc_error(SQL_HANDLE_STMT, StatementHandle, "SQLColAttribute",
|
|
print);
|
|
return TRUE;
|
|
}
|
|
|
|
/* Verificar tipo de dados*/
|
|
#define IS_SQL_INT(FIELD) \
|
|
FIELD == SQL_DECIMAL || FIELD == SQL_NUMERIC || FIELD == SQL_SMALLINT || \
|
|
FIELD == SQL_INTEGER || FIELD == SQL_TINYINT || FIELD == SQL_BIGINT
|
|
|
|
#define IS_SQL_FLOAT(FIELD) \
|
|
FIELD == SQL_FLOAT || FIELD == SQL_DOUBLE || FIELD == SQL_REAL
|
|
|
|
static Int c_db_odbc_connect(USES_REGS1) {
|
|
Term arg_driver = Deref(ARG1);
|
|
Term arg_user = Deref(ARG2);
|
|
Term arg_passwd = Deref(ARG3);
|
|
Term arg_conn = Deref(ARG4);
|
|
|
|
MYDDAS_UTIL_CONNECTION new = NULL;
|
|
|
|
const char *driver = AtomName(AtomOfTerm(arg_driver));
|
|
const char *user = AtomName(AtomOfTerm(arg_user));
|
|
const char *passwd = AtomName(AtomOfTerm(arg_passwd));
|
|
|
|
SQLHENV henv;
|
|
SQLHDBC hdbc;
|
|
|
|
/*Allocate environment handle */
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv, "connect"))
|
|
return FALSE;
|
|
/* Set the ODBC version environment attribute */
|
|
if (!SQLSETENVATTR(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0,
|
|
"connect"))
|
|
return FALSE;
|
|
/* Allocate connection handle */
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_DBC, henv, &hdbc, "connect"))
|
|
return FALSE;
|
|
/* Set login timeout to 6 seconds. */
|
|
if (!SQLSETCONNECTATTR(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)6, 0, "connect"))
|
|
return FALSE;
|
|
/* Connect to data source */
|
|
if (!SQLCONNECT(hdbc, (SQLCHAR *)driver, (SQLCHAR *)user, (SQLCHAR *)passwd,
|
|
"connect"))
|
|
return FALSE;
|
|
if (!Yap_unify(arg_conn, MkIntegerTerm((Int)(hdbc))))
|
|
return FALSE;
|
|
else {
|
|
/* Criar um novo no na lista de ligacoes*/
|
|
// new = add_connection(&TOP,hdbc,henv);
|
|
new = myddas_util_add_connection(hdbc, henv, MYDDAS_ODBC);
|
|
if (new == NULL) {
|
|
fprintf(stderr, "Error: could not allocate list memory\n");
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
/* db_query: SQLQuery x ResultSet x Arity x BindList x Connection */
|
|
static Int c_db_odbc_query(USES_REGS1) {
|
|
Term arg_sql_query = Deref(ARG1);
|
|
Term arg_result_set = Deref(ARG2);
|
|
Term arg_arity = Deref(ARG3);
|
|
Term arg_bind_list = Deref(ARG4);
|
|
Term arg_conn = Deref(ARG5);
|
|
|
|
SQLCHAR *sql = (SQLCHAR *)AtomName(AtomOfTerm(arg_sql_query));
|
|
|
|
SQLHDBC hdbc = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
SQLHSTMT hstmt;
|
|
SQLSMALLINT type;
|
|
Int arity;
|
|
Int i;
|
|
|
|
/*Allocate an handle for the query*/
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt, "db_query"))
|
|
return FALSE;
|
|
/* Executes the query*/
|
|
if (!SQLEXECDIRECT(hstmt, sql, "db_query"))
|
|
return FALSE;
|
|
|
|
if (IsNonVarTerm(arg_arity)) {
|
|
arity = IntegerOfTerm(arg_arity);
|
|
|
|
char *bind_space = NULL;
|
|
|
|
// const Int functor_arity=3;
|
|
const Short functor_arity = 3;
|
|
Functor functor = Yap_MkFunctor(Yap_LookupAtom("bind"), functor_arity);
|
|
Term properties[functor_arity];
|
|
|
|
Term head, list = arg_bind_list;
|
|
|
|
SQLULEN ColumnSizePtr;
|
|
SQLLEN *data_info = NULL;
|
|
|
|
for (i = 1; i <= arity; i++) {
|
|
head = HeadOfTerm(list);
|
|
list = TailOfTerm(list);
|
|
|
|
if (!SQLDESCRIBECOL(hstmt, i, NULL, 0, NULL, &type, &ColumnSizePtr, NULL,
|
|
NULL, "db_query"))
|
|
return FALSE;
|
|
|
|
/* +1 because of '\0' */
|
|
bind_space = malloc(sizeof(char) * (ColumnSizePtr + 1));
|
|
data_info = malloc(sizeof(SQLINTEGER));
|
|
if (!SQLBINDCOL(hstmt, i, SQL_C_CHAR, bind_space, (ColumnSizePtr + 1),
|
|
data_info, "db_query")) {
|
|
return FALSE;
|
|
}
|
|
|
|
properties[0] = MkIntegerTerm((Int)bind_space);
|
|
properties[2] = MkIntegerTerm((Int)data_info);
|
|
|
|
if (IS_SQL_INT(type))
|
|
properties[1] = MkAtomTerm(Yap_LookupAtom("integer"));
|
|
else if (IS_SQL_FLOAT(type))
|
|
properties[1] = MkAtomTerm(Yap_LookupAtom("real"));
|
|
else
|
|
properties[1] = MkAtomTerm(Yap_LookupAtom("string"));
|
|
|
|
Yap_unify(head, Yap_MkApplTerm(functor, functor_arity, properties));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (!Yap_unify(arg_result_set, MkIntegerTerm((Int)hstmt))) {
|
|
if (!SQLCLOSECURSOR(hstmt, "db_query"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_query"))
|
|
return FALSE;
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static Int c_db_odbc_number_of_fields(USES_REGS1) {
|
|
Term arg_relation = Deref(ARG1);
|
|
Term arg_conn = Deref(ARG2);
|
|
Term arg_fields = Deref(ARG3);
|
|
|
|
const char *relation = AtomName(AtomOfTerm(arg_relation));
|
|
|
|
SQLHDBC hdbc = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
SQLHSTMT hstmt;
|
|
|
|
char sql[256];
|
|
SQLSMALLINT number_fields;
|
|
|
|
sprintf(sql, "SELECT column_name from INFORMATION_SCHEMA.COLUMNS where "
|
|
"table_name = \'%s\' GROUP BY column_name, dtd_identifier ORDER "
|
|
"BY CAST(dtd_identifier AS INTEGER)",
|
|
relation);
|
|
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt, "db_number_of_fields"))
|
|
return FALSE;
|
|
if (!SQLEXECDIRECT(hstmt, (SQLCHAR *)sql, "db_number_of_fields"))
|
|
return FALSE;
|
|
|
|
/* Calcula o numero de campos*/
|
|
number_fields = 0;
|
|
while (TRUE) {
|
|
SQLFETCH(hstmt, "db_number_of_fields");
|
|
number_fields++;
|
|
}
|
|
|
|
if (!SQLCLOSECURSOR(hstmt, "db_number_of_fields"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_number_of_fields"))
|
|
return FALSE;
|
|
|
|
if (!Yap_unify(arg_fields, MkIntegerTerm(number_fields)))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/* db_get_attributes_types: RelName x Connection -> TypesList */
|
|
static Int c_db_odbc_get_attributes_types(USES_REGS1) {
|
|
Term arg_relation = Deref(ARG1);
|
|
Term arg_conn = Deref(ARG2);
|
|
Term arg_types_list = Deref(ARG3);
|
|
|
|
const char *relation = AtomName(AtomOfTerm(arg_relation));
|
|
SQLHDBC hdbc = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
SQLHSTMT hstmt;
|
|
|
|
char sql[256];
|
|
Term head, list;
|
|
list = arg_types_list;
|
|
|
|
sprintf(sql, "SELECT column_name,data_type from INFORMATION_SCHEMA.COLUMNS "
|
|
"WHERE table_name = \'%s\' GROUP BY column_name, dtd_identifier "
|
|
"ORDER BY CAST(dtd_identifier AS INTEGER)",
|
|
relation);
|
|
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt, "db_get_attributes_types"))
|
|
return FALSE;
|
|
if (!SQLEXECDIRECT(hstmt, (SQLCHAR *)sql, "db_get_attributes_types"))
|
|
return FALSE;
|
|
|
|
while (TRUE) {
|
|
SQLFETCH(hstmt, "db_get_attributes_types");
|
|
|
|
/* Tentar fazer de uma maneira que a gente consiga calcular o tamanho que o
|
|
nome do campo vai ocupar, assim podemos alocar memoria dinamicamente*/
|
|
sql[0] = '\0';
|
|
if (!SQLGETDATA(hstmt, 1, SQL_C_CHAR, sql, 256, NULL,
|
|
"db_get_attributes_types"))
|
|
return FALSE;
|
|
|
|
head = HeadOfTerm(list);
|
|
Yap_unify(head, MkAtomTerm(Yap_LookupAtom(sql)));
|
|
list = TailOfTerm(list);
|
|
head = HeadOfTerm(list);
|
|
list = TailOfTerm(list);
|
|
|
|
sql[0] = '\0';
|
|
if (!SQLGETDATA(hstmt, 2, SQL_C_CHAR, sql, 256, NULL,
|
|
"db_get_attributes_types"))
|
|
return FALSE;
|
|
|
|
if (strncmp(sql, "smallint", 8) == 0 || strncmp(sql, "int", 3) == 0 ||
|
|
strncmp(sql, "mediumint", 9) == 0 || strncmp(sql, "tinyint", 7) == 0 ||
|
|
strncmp(sql, "bigint", 6) == 0 || strcmp(sql, "year") == 0)
|
|
Yap_unify(head, MkAtomTerm(Yap_LookupAtom("integer")));
|
|
else if (strcmp(sql, "float") == 0 || strncmp(sql, "double", 6) == 0 ||
|
|
strcmp(sql, "real") == 0)
|
|
Yap_unify(head, MkAtomTerm(Yap_LookupAtom("real")));
|
|
else
|
|
Yap_unify(head, MkAtomTerm(Yap_LookupAtom("string")));
|
|
}
|
|
|
|
if (!SQLCLOSECURSOR(hstmt, "db_get_attributes_types"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_get_attributes_types"))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
/* db_disconnect */
|
|
static Int c_db_odbc_disconnect(USES_REGS1) {
|
|
Term arg_conn = Deref(ARG1);
|
|
|
|
SQLHDBC conn = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
SQLHENV henv = myddas_util_get_odbc_enviromment(conn);
|
|
|
|
if ((myddas_util_search_connection(conn)) != NULL) {
|
|
myddas_util_delete_connection(conn);
|
|
/* More information about this process on
|
|
msdn.microsoft.com*/
|
|
if (!SQLDISCONNECT(conn, "db_disconnect"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_DBC, conn, "db_disconnect"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_ENV, henv, "db_disconnect"))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
} else
|
|
return FALSE;
|
|
}
|
|
|
|
static Int c_db_odbc_row_cut(USES_REGS1) {
|
|
|
|
SQLHSTMT hstmt = (SQLHSTMT)IntegerOfTerm(EXTRA_CBACK_CUT_ARG(Term, 1));
|
|
|
|
if (!SQLCLOSECURSOR(hstmt, "db_row_cut"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_row_cut"))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int release_list_args(Term arg_list_args, Term arg_bind_list,
|
|
const char *error_msg) {
|
|
Term list = arg_list_args;
|
|
Term list_bind = arg_bind_list;
|
|
|
|
while (IsPairTerm(list_bind)) {
|
|
Term head_bind = HeadOfTerm(list_bind);
|
|
|
|
list = TailOfTerm(list);
|
|
list_bind = TailOfTerm(list_bind);
|
|
|
|
free((char *)IntegerOfTerm(ArgOfTerm(1, head_bind)));
|
|
free((SQLINTEGER *)IntegerOfTerm(ArgOfTerm(3, head_bind)));
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* db_row: ResultSet x BindList x ListOfArgs -> */
|
|
static Int c_db_odbc_row(USES_REGS1) {
|
|
Term arg_result_set = Deref(ARG1);
|
|
Term arg_bind_list = Deref(ARG2);
|
|
Term arg_list_args = Deref(ARG3);
|
|
|
|
SQLHSTMT hstmt = (SQLHSTMT)IntegerOfTerm(arg_result_set);
|
|
|
|
/* EXTRA_CBACK_ARG(ARIDADE,LOCAL_ONDE_COLOCAR_VALOR)*/
|
|
EXTRA_CBACK_ARG(3, 1) = (CELL)MkIntegerTerm((Int)hstmt);
|
|
|
|
Term head, list, null_atom[1];
|
|
Term head_bind, list_bind;
|
|
|
|
SQLRETURN retcode = SQLFetch(hstmt);
|
|
if (retcode == SQL_NO_DATA) {
|
|
if (!SQLCLOSECURSOR(hstmt, "db_row"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_row"))
|
|
return FALSE;
|
|
if (!release_list_args(arg_list_args, arg_bind_list, "db_row")) {
|
|
return FALSE;
|
|
}
|
|
|
|
cut_fail();
|
|
return FALSE;
|
|
}
|
|
if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) {
|
|
printf("erro no SQLFETCH number of fields\n");
|
|
return FALSE;
|
|
}
|
|
|
|
char *bind_value = NULL;
|
|
Term type;
|
|
|
|
list = arg_list_args;
|
|
list_bind = arg_bind_list;
|
|
SQLINTEGER *data_info = NULL;
|
|
|
|
while (IsPairTerm(list_bind)) {
|
|
head = HeadOfTerm(list);
|
|
list = TailOfTerm(list);
|
|
|
|
head_bind = HeadOfTerm(list_bind);
|
|
list_bind = TailOfTerm(list_bind);
|
|
|
|
bind_value = (char *)IntegerOfTerm(ArgOfTerm(1, head_bind));
|
|
type = ArgOfTerm(2, head_bind);
|
|
data_info = (SQLINTEGER *)IntegerOfTerm(ArgOfTerm(3, head_bind));
|
|
|
|
if ((*data_info) == SQL_NULL_DATA) {
|
|
null_atom[0] = MkIntegerTerm(null_id++);
|
|
if (!Yap_unify(head,
|
|
Yap_MkApplTerm(Yap_MkFunctor(Yap_LookupAtom("null"), 1), 1,
|
|
null_atom)))
|
|
continue;
|
|
} else {
|
|
|
|
if (!strcmp(AtomName(AtomOfTerm(type)), "integer")) {
|
|
if (!Yap_unify(head, MkIntegerTerm(atol(bind_value))))
|
|
continue;
|
|
} else if (!strcmp(AtomName(AtomOfTerm(type)), "real")) {
|
|
if (!Yap_unify(head, MkFloatTerm(atof(bind_value))))
|
|
continue;
|
|
} else if (!strcmp(AtomName(AtomOfTerm(type)), "string")) {
|
|
if (!Yap_unify(head, MkAtomTerm(Yap_LookupAtom(bind_value))))
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* Mudar esta funcao de forma a nao fazer a consulta, pois
|
|
no predicate db_sql_selet vai fazer duas vezes a mesma consutla*/
|
|
static Int c_db_odbc_number_of_fields_in_query(USES_REGS1) {
|
|
Term arg_query = Deref(ARG1);
|
|
Term arg_conn = Deref(ARG2);
|
|
Term arg_fields = Deref(ARG3);
|
|
|
|
const char *sql = AtomName(AtomOfTerm(arg_query));
|
|
|
|
SQLHDBC hdbc = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
SQLHSTMT hstmt;
|
|
SQLSMALLINT number_cols = 0;
|
|
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt,
|
|
"db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
if (!SQLEXECDIRECT(hstmt, (SQLCHAR *)sql, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
|
|
if (!SQLNUMRESULTCOLS(hstmt, &number_cols, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
|
|
if (!Yap_unify(arg_fields, MkIntegerTerm(number_cols))) {
|
|
if (!SQLCLOSECURSOR(hstmt, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (!SQLCLOSECURSOR(hstmt, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt, "db_number_of_fields_in_query"))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#ifdef MYDDAS_ODBC
|
|
/* This function searches the MYDDAS list for odbc connections
|
|
If there isn't any, it returns NULL. This is a nice way to know
|
|
if there is any odbc connections left on the list*/
|
|
SQLHENV
|
|
myddas_util_get_odbc_enviromment(SQLHDBC connection) {
|
|
CACHE_REGS
|
|
MYDDAS_UTIL_CONNECTION top =
|
|
Yap_REGS.MYDDAS_GLOBAL_POINTER->myddas_top_connections;
|
|
|
|
for (; top != NULL; top = top->next)
|
|
if (top->connection == ((void *)connection))
|
|
return top->odbc_enviromment;
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static Int c_db_odbc_get_fields_properties(USES_REGS1) {
|
|
Term nome_relacao = Deref(ARG1);
|
|
Term arg_conn = Deref(ARG2);
|
|
Term fields_properties_list = Deref(ARG3);
|
|
Term head, list;
|
|
|
|
SQLCHAR *relacao = (SQLCHAR *)AtomName(AtomOfTerm(nome_relacao));
|
|
char sql[256];
|
|
char name[200];
|
|
Int i;
|
|
|
|
SQLSMALLINT num_fields = 0;
|
|
SQLSMALLINT NullablePtr = 0;
|
|
SQLLEN AutoIncrementPointer = 0;
|
|
SQLHSTMT hstmt, hstmt2;
|
|
SQLHDBC hdbc = (SQLHDBC)(IntegerOfTerm(arg_conn));
|
|
|
|
/* LIMIT 0 -> We don't need the results of the query,
|
|
only the information about the fields of the relation*/
|
|
sprintf(sql, "SELECT * FROM `%s` LIMIT 0", relacao);
|
|
|
|
/*Allocate an handle for the query*/
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt,
|
|
"db_get_fields_properties"))
|
|
return FALSE;
|
|
/* Executes the query*/
|
|
if (!SQLEXECDIRECT(hstmt, (SQLCHAR *)sql, "db_get_fields_properties"))
|
|
return FALSE;
|
|
|
|
Functor functor = Yap_MkFunctor(Yap_LookupAtom("property"), 4);
|
|
Term properties[4];
|
|
|
|
if (!SQLNUMRESULTCOLS(hstmt, &num_fields, "db_get_fields_properties"))
|
|
return FALSE;
|
|
|
|
list = fields_properties_list;
|
|
|
|
SQLSMALLINT bind_prim_key;
|
|
// rows in odbc start at 1 :)
|
|
Short *null = (Short *)malloc(sizeof(Short) * (1 + num_fields));
|
|
|
|
if (!SQLALLOCHANDLE(SQL_HANDLE_STMT, hdbc, &hstmt2,
|
|
"db_get_fields_properties"))
|
|
return FALSE;
|
|
/* Executes the query*/
|
|
if (!SQLPRIMARYKEYS(hstmt2, NULL, 0, NULL, 0, relacao, SQL_NTS,
|
|
"db_get_fields_properties"))
|
|
return FALSE;
|
|
/* Associates bind value for the 5 column*/
|
|
if (!SQLBINDCOL(hstmt2, 5, SQL_C_SSHORT, &bind_prim_key, sizeof(SQLSMALLINT),
|
|
NULL, "db_get_fields_properties"))
|
|
return FALSE;
|
|
|
|
while (1) {
|
|
SQLFETCH(hstmt2, "db_get_fields_properties");
|
|
null[bind_prim_key] = 1;
|
|
}
|
|
|
|
if (!SQLCLOSECURSOR(hstmt2, "db_get_fields_properties"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt2, "db_get_fields_properties"))
|
|
return FALSE;
|
|
|
|
for (i = 1; i <= num_fields; i++) {
|
|
head = HeadOfTerm(list);
|
|
name[0] = '\0';
|
|
SQLDESCRIBECOL(hstmt, i, (SQLCHAR *)name, 200, NULL, NULL, NULL, NULL,
|
|
&NullablePtr, "db_get_fields_properties");
|
|
|
|
if (!SQLCOLATTRIBUTE(hstmt, i, SQL_DESC_AUTO_UNIQUE_VALUE, NULL, 0, NULL,
|
|
&AutoIncrementPointer, "db_get_fields_properties"))
|
|
return FALSE;
|
|
|
|
properties[0] = MkAtomTerm(Yap_LookupAtom(name));
|
|
|
|
if (NullablePtr & SQL_NULLABLE)
|
|
properties[1] = MkIntegerTerm(1); // Can't be NULL
|
|
else
|
|
properties[1] = MkIntegerTerm(0);
|
|
|
|
if (null[i] == 1)
|
|
properties[2] = MkIntegerTerm(1); // It''s a primary key
|
|
else
|
|
properties[2] = MkIntegerTerm(0);
|
|
|
|
if (AutoIncrementPointer & SQL_TRUE)
|
|
properties[3] = MkIntegerTerm(1); // It's auto_incremented field
|
|
else
|
|
properties[3] = MkIntegerTerm(0);
|
|
|
|
list = TailOfTerm(list);
|
|
if (!Yap_unify(head, Yap_MkApplTerm(functor, 4, properties))) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!SQLCLOSECURSOR(hstmt, "db_get_fields_properties"))
|
|
return FALSE;
|
|
if (!SQLFREEHANDLE(SQL_HANDLE_STMT, hstmt2, "db_get_fields_properties"))
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
void Yap_InitMYDDAS_ODBCPreds(void) {
|
|
/* db_connect: Host x User x Passwd x Database x Connection */
|
|
Yap_InitCPred("c_db_odbc_connect", 4, c_db_odbc_connect, 0);
|
|
|
|
/* db_number_of_fields: Relation x Connection x NumberOfFields */
|
|
Yap_InitCPred("c_db_odbc_number_of_fields", 3, c_db_odbc_number_of_fields, 0);
|
|
|
|
/* db_number_of_fields_in_query: SQLQuery x Connection x NumberOfFields */
|
|
Yap_InitCPred("c_db_odbc_number_of_fields_in_query", 3,
|
|
c_db_odbc_number_of_fields_in_query, 0);
|
|
|
|
/* db_get_attributes_types: Relation x TypesList */
|
|
Yap_InitCPred("c_db_odbc_get_attributes_types", 3,
|
|
c_db_odbc_get_attributes_types, 0);
|
|
|
|
/* db_query: SQLQuery x ResultSet x Connection */
|
|
Yap_InitCPred("c_db_odbc_query", 5, c_db_odbc_query, 0);
|
|
|
|
/* db_disconnect: Connection */
|
|
Yap_InitCPred("c_db_odbc_disconnect", 1, c_db_odbc_disconnect, 0);
|
|
|
|
/* db_get_fields_properties: PredName x Connnection x PropertiesList */
|
|
Yap_InitCPred("c_db_odbc_get_fields_properties", 3,
|
|
c_db_odbc_get_fields_properties, 0);
|
|
}
|
|
|
|
void Yap_InitBackMYDDAS_ODBCPreds(void) {
|
|
|
|
/* db_row: ResultSet x ListOfArgs */
|
|
Yap_InitCPredBackCut("c_db_odbc_row", 3, sizeof(Int), c_db_odbc_row,
|
|
c_db_odbc_row, c_db_odbc_row_cut, 0);
|
|
}
|
|
#else
|
|
|
|
void Yap_InitMYDDAS_ODBCPreds(void) {}
|
|
void Yap_InitBackMYDDAS_ODBCPreds(void) {}
|
|
|
|
#endif
|
|
|
|
void init_odbc( void )
|
|
{
|
|
Yap_InitMYDDAS_ODBCPreds();
|
|
Yap_InitBackMYDDAS_ODBCPreds();
|
|
}
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include <windows.h>
|
|
|
|
int WINAPI win_odbc(HANDLE hinst, DWORD reason, LPVOID reserved);
|
|
|
|
int WINAPI win_odbc(HANDLE hinst, DWORD reason, LPVOID reserved) {
|
|
switch (reason) {
|
|
case DLL_PROCESS_ATTACH:
|
|
break;
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
case DLL_THREAD_ATTACH:
|
|
break;
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
#endif
|
|
/*MYDDAS_ODBC*/
|