static NEOERR* pgsql_mdb_query_getv(mdb_conn* conn, const char* fmt, va_list ap)
{
PGresult* res = CONN(conn)->pg_res;
int row_no = CONN(conn)->row_no;
NEOERR *err = STATUS_OK;
if (res == NULL) return nerr_raise(NERR_DB, "attemp fetch null res");
if (row_no >= mdb_get_rows(conn)) {
if (row_no == 0) return nerr_raise(NERR_NOT_FOUND, "empty result");
return nerr_raise(NERR_OUTOFRANGE, "last row has fetched");
}
int param_count = fmt != NULL ? strlen(fmt) : 0;
int i, col = 0;
for (i = 0; i < param_count; i++) {
if (fmt[i] == 's') {
char** str_ptr = (char**)va_arg(ap, char**);
if (PQgetisnull(res, row_no, col))
*str_ptr = NULL;
else
*str_ptr = PQgetvalue(res, row_no, col);
col++;
} else if (fmt[i] == 'S') {
CPINLINE int CP_CLIENT_SERIALIZE_SEND_MEM(zval *ret_value, cpClient *cli)
{
int pipe_fd_write = get_writefd(CONN(cli)->worker_id);
instead_smart dest;
dest.len = 0;
dest.addr = get_attach_buf(CONN(cli)->worker_id, CPGS->max_buffer_len, CPGS->G[CONN(cli)->group_id].workers[CONN(cli)->worker_index].sm_obj.mmap_name);
dest.max = CPGS->max_buffer_len;
dest.exceed = 0;
php_msgpack_serialize(&dest, ret_value);
if (dest.exceed == 1)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "data is exceed,increase max_read_len Error: %s [%d] ", strerror(errno), errno);
}
else
{
cpWorkerInfo worker_event;
worker_event.len = dest.len;
worker_event.pid = cpPid;
worker_event.type = 0; //暫時沒用
int ret = write(pipe_fd_write, &worker_event, sizeof (worker_event));
if (ret == -1)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "write error Error: %s [%d]", strerror(errno), errno);
}
return SUCCESS;
}
return FAILURE;
}
static NEOERR* mysql_mdb_query_getv(mdb_conn* conn, const char* fmt, va_list ap)
{
MYSQL_RES* res = CONN(conn)->res;
MYSQL_ROW row = CONN(conn)->row;
int row_no = CONN(conn)->row_no;
NEOERR *err = STATUS_OK;
if (res == NULL) return nerr_raise(NERR_DB, "attemp fetch null res");
if (row_no >= mdb_get_rows(conn)) {
if (row_no == 0) return nerr_raise(NERR_NOT_FOUND, "empty result");
return nerr_raise(NERR_OUTOFRANGE, "last row has fetched");
}
int param_count = fmt != NULL ? strlen(fmt) : 0;
int i, col = 0;
row = mysql_fetch_row(res);
if (!row) return nerr_raise(NERR_OUTOFRANGE, "last row has fetched");
if (param_count > mysql_num_fields(res))
return nerr_raise(NERR_ASSERT, "result col num not match");
for (i = 0; i < param_count; i++) {
if (fmt[i] == 's') {
char** str_ptr = (char**)va_arg(ap, char**);
if (row[col] == NULL)
*str_ptr = NULL;
else
*str_ptr = row[col];
col++;
} else if (fmt[i] == 'S') {
static NEOERR* mysql_mdb_rollback(mdb_conn* conn)
{
if (mysql_rollback(CONN(conn)->mysql) != 0)
return nerr_raise(NERR_DB, mysql_error(CONN(conn)->mysql));
return STATUS_OK;
}
static NEOERR* mysql_mdb_begin(mdb_conn* conn)
{
if (mysql_real_query(CONN(conn)->mysql, "BEGIN", strlen("BEGIN")) != 0)
return nerr_raise(NERR_DB, mysql_error(CONN(conn)->mysql));
return STATUS_OK;
}
static sdb_conn_t *
mock_conn_create(void)
{
mock_conn_t *conn;
conn = calloc(1, sizeof(*conn));
if (! conn) {
fail("INTERNAL ERROR: failed to allocate connection object");
return NULL;
}
SDB_OBJ(conn)->name = "mock_connection";
SDB_OBJ(conn)->ref_cnt = 1;
conn->conn.buf = sdb_strbuf_create(0);
conn->conn.errbuf = sdb_strbuf_create(0);
conn->write_buf = sdb_strbuf_create(64);
if ((! conn->conn.buf) || (! conn->conn.errbuf) || (! conn->write_buf)) {
mock_conn_destroy(CONN(conn));
fail("INTERNAL ERROR: failed to allocate connection object");
return NULL;
}
conn->conn.read = mock_conn_read;
conn->conn.write = mock_conn_write;
conn->conn.username = "******";
conn->conn.cmd = SDB_CONNECTION_IDLE;
conn->conn.cmd_len = 0;
return CONN(conn);
} /* mock_conn_create */
static void pgsql_mdb_disconnect(mdb_conn* conn)
{
if (CONN(conn)->pg)
PQfinish(CONN(conn)->pg);
if (CONN(conn)->pg_res != NULL)
PQclear(CONN(conn)->pg_res);
CONN(conn)->pg_res = NULL;
}
void IoEvConnection_free(IoEvConnection *self)
{
if (CONN(self))
{
evhttp_connection_free(CONN(self));
IoObject_setDataPointer_(self, 0x0);
}
}
static NEOERR* pgsql_mdb_query_fill(mdb_conn* conn, const char* sql_string)
{
if (CONN(conn)->pg_res != NULL)
PQclear(CONN(conn)->pg_res);
CONN(conn)->pg_res = NULL;
CONN(conn)->row_no = 0;
if (conn->sql) free(conn->sql);
conn->sql = NULL;
if (sql_string) conn->sql = strdup(sql_string);
return STATUS_OK;
}
IoObject *IoEvConnection_connect(IoEvConnection *self, IoObject *locals, IoMessage *m)
{
IoEventManager *em = IoObject_getSlot_(self, IOSYMBOL("eventManager"));
IoSeq *address = IoObject_seqGetSlot_(self, IOSYMBOL("address"));
int port = IoObject_doubleGetSlot_(self, IOSYMBOL("port"));
IOASSERT(CONN(self) == 0x0, "already have connection");
IOASSERT(ISEEVENTMANAGER(em), "eventManager slot not set properly");
//printf("IoEventManager_rawBase(em) = %p\n", (void *)IoEventManager_rawBase(em));
IoObject_setDataPointer_(self, evhttp_connection_new(CSTRING(address), port));
evhttp_connection_set_base(CONN(self), IoEventManager_rawBase(em));
evhttp_connection_set_closecb(CONN(self), IoEvConnection_ConnectionCloseCallback, self);
return self;
}
int main (int argc, char *argv[]) {
MYSQL *mysql;
MYSQL_RES *result;
MYSQL_ROW row;
my_bool reconnect = 0;
mysql = mysql_init(NULL);
mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
CONN(0);
MYSQL_STMT *stmt;
MYSQL_BIND bind[7];
my_ulonglong affected_rows;
int param_count;
short small_data;
int int_data;
char str_data[STRING_SIZE];
unsigned long str_length;
my_bool is_null;
mysql_query(mysql, "select * from d limit 100000");
result = mysql_store_result(mysql);
while(mysql_fetch_row(result));
mysql_close(mysql);
}
ret_t
cherokee_logger_write_access (cherokee_logger_t *logger, void *conn)
{
ret_t ret;
/* Sanity check
*/
if (unlikely (logger->write_access == NULL)) {
return ret_error;
}
/* Deal with X-Real-IP
*/
if (logger->priv->x_real_ip.enabled) {
ret = parse_x_real_ip (logger, CONN(conn));
if (unlikely (ret == ret_error)) {
return ret_error;
}
}
/* Call the virtual method
*/
CHEROKEE_MUTEX_LOCK (&PRIV(logger)->mutex);
ret = logger->write_access (logger, conn);
CHEROKEE_MUTEX_UNLOCK (&PRIV(logger)->mutex);
return ret;
}
int main(int argc, char* argv[])
{
MYSQL *mysql,*sock;
MYSQL_ROW row;
MYSQL_RES *result;
mysql = mysql_init(NULL);
if (!(sock = CONN(CLIENT_MULTI_STATEMENTS))) {
fprintf(stderr, "Couldn't connect to engine!\n%s\n\n", mysql_error(mysql));
perror("");
exit(1);
}
char *sql = "select 1;select * from n";
mysql_query(sock, sql);
do
{
printf("total affected rows: %lld\n", mysql_affected_rows(sock));
if (!(result= mysql_store_result(sock)))
{
printf("Got fatal error processing query\n");
exit(1);
}
row = mysql_fetch_row(result);
printf("%s\n", row[0]);
mysql_free_result(result);
} while (!mysql_next_result(sock));
return 0;
}
int main (int argc, char *argv[]) {
MYSQL *mysql;
MYSQL_RES *result;
MYSQL_ROW row;
my_bool reconnect = 0;
mysql = mysql_init(NULL);
mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
CONN(0);
MYSQL_STMT *stmt;
MYSQL_BIND bind[7];
my_ulonglong affected_rows;
int param_count;
short small_data;
int int_data;
char str_data[STRING_SIZE];
unsigned long str_length;
my_bool is_null;
int id = mysql_query(mysql, SQL);
result = mysql_store_result(mysql);
printf("%d %d\n", id, mysql_errno(mysql));
if (result)
while(mysql_fetch_row(result)) {
printf("ok\n");
}
mysql_close(mysql);
}
ret_t
cherokee_validator_check (cherokee_validator_t *validator, void *conn)
{
if (validator->check == NULL) {
return ret_error;
}
return validator->check (validator, CONN(conn));
}
ret_t
cherokee_validator_add_headers (cherokee_validator_t *validator,
void *conn,
cherokee_buffer_t *buf)
{
if (validator->add_headers == NULL) {
return ret_error;
}
return validator->add_headers (validator, CONN(conn), buf);
}
static NEOERR* pgsql_mdb_rollback(mdb_conn* conn)
{
PGresult* res;
NEOERR *err = STATUS_OK;
res = PQexec(CONN(conn)->pg, "ROLLBACK");
if (PQresultStatus(res) != PGRES_COMMAND_OK)
err = nerr_raise(NERR_DB, PQresultErrorMessage(res));
PQclear(res);
return err;
}
int main()
{
int i,n,j,a[CON(SIZE)+1]={0};
n=(int)ceil(sqrt(SIZE));n=CON(n);
for(i=0;i<n;i++)
{
if(a[i]==0)
for(j=CON2(i);j<CON(SIZE);j+=ICON(i))
a[j]=1;
}
j=0;
for(i=0;i<=CON(SIZE);i++)
if(a[i]==0)
{
prime[j]=ICON(i);
j++;
}
int t,m,f;
scanf("%d",&t);
while(t--)
{
int b[100010]={0},s=0;
scanf("%d%d",&m,&n);
if(m<=2)printf("2\n"),m=3;
if(m%2==0)m++;
if(n%2==0)n--;
f=(int)sqrt(n);
for(i=0;i<3401;i++)
{
if(prime[i]>f)break;
int start;
if(m>=prime[i])
{
start=m+prime[i]-m%prime[i];
if(start%2==0)start+=prime[i];
start-=m;
if(m%prime[i]==0 &&m!=prime[i])start=0;
}
else start=prime[i]*prime[i]-m;
for(j=CONN(start);j<=(n-m)/2;j+=prime[i])
b[j]=1;
}
for(i=0;i<=(n-m)/2;i++)
if(b[i]==0)
// s++;
printf("%d\n",ICON2(i)+m);
// printf("%d\n",s);
printf("\n");
}
return 0;
}
static void mysql_mdb_disconnect(mdb_conn* conn)
{
if (CONN(conn)->mysql != NULL)
mysql_close(CONN(conn)->mysql);
CONN(conn)->mysql = NULL;
if (CONN(conn)->res != NULL)
mysql_free_result(CONN(conn)->res);
CONN(conn)->res = NULL;
}
static SQLRETURN
_SQLExecute_ConvParams (SQLHSTMT hstmt, BOOL bOutput)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
ENVR (penv, pdbc->henv);
PPARM pparm;
int maxpar;
int i;
SQLULEN j;
SQLULEN cRows = pstmt->paramset_size;
if (penv->unicode_driver)
return SQL_SUCCESS;
if (cRows == 0)
cRows = 1;
maxpar = pstmt->st_nparam;
pparm = pstmt->st_pparam;
for (i = 0; i < maxpar; i++, pparm++)
{
if (pparm->pm_data == NULL)
continue;
if (bOutput && (pparm->pm_usage == SQL_PARAM_OUTPUT || pparm->pm_usage == SQL_PARAM_INPUT_OUTPUT))
{
if (pparm->pm_c_type_orig != SQL_C_WCHAR)
continue;
for (j = 0; j < cRows; j++)
_ConvParam(pstmt, pparm, j, bOutput);
}
else if (!bOutput && (pparm->pm_usage == SQL_PARAM_INPUT || pparm->pm_usage == SQL_PARAM_INPUT_OUTPUT))
{
if (pparm->pm_c_type != SQL_C_WCHAR)
continue;
for (j = 0; j < cRows; j++)
_ConvParam(pstmt, pparm, j, bOutput);
pparm->pm_c_type = SQL_C_CHAR;
}
} /* next column */
return SQL_SUCCESS;
}
static void
connection_destroy(sdb_object_t *obj)
{
sdb_conn_t *conn;
size_t len;
assert(obj);
conn = CONN(obj);
conn->ready = 0;
if (conn->finish)
conn->finish(conn);
conn->finish = NULL;
if (conn->buf) {
len = sdb_strbuf_len(conn->buf);
if (len)
sdb_log(SDB_LOG_INFO, "frontend: Discarding incomplete command "
"(%zu byte%s left in buffer)", len, len == 1 ? "" : "s");
}
if (conn->client_addr.ss_family == AF_UNIX) {
sdb_log(SDB_LOG_DEBUG, "frontend: Closing connection %s from peer %s",
obj->name, conn->username);
}
else {
char host[1024] = "<unknown>", port[32] = "";
getnameinfo((struct sockaddr *)&conn->client_addr,
conn->client_addr_len, host, sizeof(host), port, sizeof(port),
NI_NUMERICHOST | NI_NUMERICSERV);
sdb_log(SDB_LOG_DEBUG, "frontend: Closing connection %s from peer %s "
"at %s:%s", obj->name, conn->username, host, port);
}
sdb_connection_close(conn);
if (conn->username)
free(conn->username);
conn->username = NULL;
sdb_strbuf_destroy(conn->buf);
conn->buf = NULL;
sdb_strbuf_destroy(conn->errbuf);
conn->errbuf = NULL;
} /* connection_destroy */
ret_t
cherokee_post_read_header (cherokee_post_t *post,
void *cnt)
{
ret_t ret;
char *info = NULL;
cuint_t info_len = 0;
cherokee_connection_t *conn = CONN(cnt);
switch (post->read_header_phase) {
case cherokee_post_read_header_init:
/* Read the header
*/
ret = parse_header (post, conn);
if (unlikely (ret != ret_ok)) {
return ret;
}
post->has_info = true;
ret = remove_surplus (post, conn);
if (unlikely (ret != ret_ok)) {
return ret;
}
/* Expect: 100-continue
* http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html
*/
ret = cherokee_header_get_known (&conn->header, header_expect, &info, &info_len);
if (likely (ret != ret_ok)) {
return ret_ok;
}
cherokee_buffer_add_str (&post->read_header_100cont, HTTP_100_RESPONSE);
post->read_header_phase = cherokee_post_read_header_100cont;
case cherokee_post_read_header_100cont:
return reply_100_continue (post, conn);
}
SHOULDNT_HAPPEN;
return ret_error;
}
static void* connect_pool_perisent(zval* zres, zval* data_source)
{
// cpLog_init("/tmp/pool_client.log");
zend_rsrc_list_entry sock_le;
int ret;
cpClient* cli = (cpClient*) pecalloc(sizeof (cpClient), 1, 1);
if (cpClient_create(cli) < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "pdo_connect_pool: create sock fail. Error: %s [%d]", strerror(errno), errno);
}
ret = cpClient_connect(cli, "127.0.0.1", 6253, (float) 100, 0); //所有的操作100s超时
if (ret < 0)
{
pefree(cli, 1);
return NULL;
}
sock_le.type = le_cli_connect_pool;
sock_le.ptr = cli;
ZEND_REGISTER_RESOURCE(zres, cli, le_cli_connect_pool);
zend_hash_update(&EG(persistent_list), Z_STRVAL_P(data_source), Z_STRLEN_P(data_source), (void*) &sock_le, sizeof (zend_rsrc_list_entry), NULL);
cli->lock = cpMutexLock;
cli->unLock = cpMutexUnLock;
cpTcpEvent event = {0};
event.type = CP_TCPEVENT_GETFD;
cpClient_send(cli->sock, (char *) &event, sizeof (event), 0);
cpMasterInfo info;
ret = cpClient_recv(cli->sock, &info, sizeof (cpMasterInfo), 1);
if (ret < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "recv from pool server error [%d],%s", errno, strerror(errno));
}
cli->server_fd = info.server_fd;
cpClient_attach_mem();
CONN(cli)->release = CP_FD_RELEASED;
return cli;
}
int main(int argc, char* argv[])
{
MYSQL *mysql,*sock;
MYSQL_ROW row;
MYSQL_RES *result;
mysql = mysql_init(NULL);
if (!(sock = CONN(0))) {
fprintf(stderr, "Couldn't connect to engine!\n%s\n\n", mysql_error(mysql));
perror("");
exit(1);
}
// simple
char sql[100] = {};
sprintf(sql, "INSERT INTO blob_test(a, b) VALUE (1, 2)");
mysql_query(sock, sql);
mysql_query(sock, "select * from blob_test");
result = mysql_store_result(mysql);
mysql_free_result(result);
#define INSERT_QUERY "INSERT INTO blob_test(a, b) VALUES(?,?)"
MYSQL_STMT *stmt;
MYSQL_BIND bind[2];
long length;
int int_data = 10;
char str[100];
int ret;
stmt = mysql_stmt_init(mysql);
mysql_stmt_prepare(stmt, INSERT_QUERY, strlen(INSERT_QUERY));
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= 0;
bind[1].buffer_type= MYSQL_TYPE_BLOB;
bind[1].buffer = (char*)&str;
bind[1].is_null= 0;
mysql_stmt_bind_param(stmt, bind);
ret = mysql_stmt_send_long_data(stmt,1,"fails",5);
ret = mysql_stmt_send_long_data(stmt,1," - The most popular Open Source database",40);
mysql_stmt_execute(stmt);
mysql_stmt_close(stmt);
stmt = mysql_stmt_init(mysql);
mysql_stmt_prepare(stmt, INSERT_QUERY, strlen(INSERT_QUERY));
size_t s = sizeof(str);
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= 0;
bind[1].buffer_type= MYSQL_TYPE_BLOB;
bind[1].buffer = (char*)&str;
bind[1].is_null= 0;
bind[1].length= (char*)&s;
mysql_stmt_bind_param(stmt, bind);
snprintf(str, sizeof(str), "%s", "this success");
mysql_stmt_execute(stmt);
mysql_stmt_close(stmt);
return 0;
}
CPINLINE cpGroup * cpGet_worker(cpClient *cli, zval **data_source)
{
cpGroup *G = NULL;
int group_id, worker_index;
for (group_id = 0; group_id < CPGS->group_num; group_id++)
{
if (strcmp(Z_STRVAL_PP(data_source), CPGS->G[group_id].name) == 0)
{
G = &CPGS->G[group_id];
cpConnection *conn = CONN(cli);
if (cli->lock(G) == 0)
{
for (worker_index = 0; worker_index < G->worker_num; worker_index++)
{
if (G->workers_status[worker_index] == CP_WORKER_IDLE && worker_index < G->worker_max)
{
G->workers_status[worker_index] = CP_WORKER_BUSY;
G->workers[worker_index].CPid = cpPid; //worker for this pid
conn->release = CP_FD_NRELEASED;
conn->worker_id = group_id * CP_GROUP_LEN + worker_index;
conn->group_id = group_id;
conn->worker_index = worker_index;
break;
}
}
if (conn->release == CP_FD_RELEASED)
{
if (G->worker_num < G->worker_max)
{//add
conn->worker_index = G->worker_num;
conn->release = CP_FD_NRELEASED;
conn->worker_id = group_id * CP_GROUP_LEN + conn->worker_index;
conn->group_id = group_id;
G->workers_status[conn->worker_index] = CP_WORKER_BUSY;
G->workers[conn->worker_index].CPid = cpPid; //worker for this pid
cpCreate_worker_mem(conn->worker_index, group_id);
cpTcpEvent event = {0};
event.type = CP_TCPEVENT_ADD;
event.data = conn->worker_index;
// event.ClientPid = cpPid;
G->worker_num++; //add first, for thread safe
int ret = cpClient_send(cli->sock, (char *) &event, sizeof (event), 0);
if (ret < 0)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "send to server errro %s [%d]", strerror(errno), errno);
}
}
else
{// in queue
conn->wait_fpm_pid = cpPid;
conn->next_wait_id = 0;
if (G->last_wait_id)
{
CPGS->conlist[G->last_wait_id].next_wait_id = cli->server_fd;
G->last_wait_id = cli->server_fd;
}
else
{
G->first_wait_id = G->last_wait_id = cli->server_fd;
}
conn->release = CP_FD_WAITING;
conn->group_id = group_id;
}
}
cli->unLock(G);
}
break;
}
}
return G;
}
/*!
For 3D and 2D.
@par Revision history:
- 08.06.2006, c
- 02.08.2006
*/
int32 orient_elements( int32 *flag, int32 flag_n_row,
int32 *conn, int32 conn_n_row, int32 conn_n_col,
float64 *coors, int32 coors_n_row, int32 coors_n_col,
int32 *v_roots, int32 v_roots_n_row,
int32 *v_vecs, int32 v_vecs_n_row, int32 v_vecs_n_col,
int32 *swap_from, int32 swap_from_n_row, int32 swap_from_n_col,
int32 *swap_to, int32 swap_to_n_row, int32 swap_to_n_col )
{
#define IR( iel, ir ) (conn[conn_n_col*(iel)+v_roots[ir]])
#define IV( iel, ir, iv ) (conn[conn_n_col*(iel)+v_vecs[v_vecs_n_col*ir+iv]])
#define CONN( iel, ip ) (conn[conn_n_col*(iel)+ip])
#define SWF( ir, is ) (swap_from[swap_from_n_col*ir+is])
#define SWT( ir, is ) (swap_to[swap_to_n_col*ir+is])
int32 ir, iel, ii, ip0, ip1, ip2, ip3, tmp, nc;
float64 v0[3], v1[3], v2[3], v3[3], cross[3], dot[1];
nc = coors_n_col;
if (nc == 4) { // 3D.
for (iel = 0; iel < conn_n_row; iel++) {
flag[iel] = 0;
for (ir = 0; ir < v_roots_n_row; ir++) {
ip0 = IR( iel, ir );
ip1 = IV( iel, ir, 0 );
ip2 = IV( iel, ir, 1 );
ip3 = IV( iel, ir, 2 );
for (ii = 0; ii < 3; ii++) {
v0[ii] = coors[nc*ip0+ii];
v1[ii] = coors[nc*ip1+ii] - v0[ii];
v2[ii] = coors[nc*ip2+ii] - v0[ii];
v3[ii] = coors[nc*ip3+ii] - v0[ii];
}
gtr_cross_product( cross, v1, v2 );
gtr_dot_v3( dot, v3, cross );
/* output( "%d %d -> %d %d %d %d %e\n", iel, ir, ip0, ip1, ip2, ip3, */
/* dot[0] ); */
if (dot[0] < CONST_MachEps) {
flag[iel]++;
for (ii = 0; ii < swap_from_n_col; ii++) {
SwapValues( CONN( iel, SWF( ir, ii ) ),
CONN( iel, SWT( ir, ii ) ), tmp );
/* output( "%d %d\n", SWF( ir, ii ), SWT( ir, ii ) ); */
}
}
}
/* sys_pause(); */
}
} else if (nc == 3) { // 2D.
for (iel = 0; iel < conn_n_row; iel++) {
flag[iel] = 0;
for (ir = 0; ir < v_roots_n_row; ir++) {
ip0 = IR( iel, ir );
ip1 = IV( iel, ir, 0 );
ip2 = IV( iel, ir, 1 );
for (ii = 0; ii < 2; ii++) {
v0[ii] = coors[nc*ip0+ii];
v1[ii] = coors[nc*ip1+ii] - v0[ii];
v2[ii] = coors[nc*ip2+ii] - v0[ii];
}
v1[2] = v2[2] = 0.0;
gtr_cross_product( cross, v1, v2 );
if (cross[2] < CONST_MachEps) {
flag[iel]++;
for (ii = 0; ii < swap_from_n_col; ii++) {
SwapValues( CONN( iel, SWF( ir, ii ) ),
CONN( iel, SWT( ir, ii ) ), tmp );
}
}
}
}
}
return( RET_OK );
#undef IR
#undef IV
#undef CONN
#undef SWF
#undef SWT
}
SQLRETURN SQL_API
SQLPrepare_Internal (
SQLHSTMT hstmt,
SQLPOINTER szSqlStr,
SQLINTEGER cbSqlStr,
SQLCHAR waMode)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
ENVR (penv, pdbc->henv);
HPROC hproc = SQL_NULL_HPROC;
SQLRETURN retcode = SQL_SUCCESS;
sqlstcode_t sqlstat = en_00000;
void * _SqlStr = NULL;
/* check state */
if (pstmt->asyn_on == en_NullProc)
{
/* not on asyn state */
switch (pstmt->state)
{
case en_stmt_fetched:
case en_stmt_xfetched:
sqlstat = en_24000;
break;
case en_stmt_needdata:
case en_stmt_mustput:
case en_stmt_canput:
sqlstat = en_S1010;
break;
default:
break;
}
}
else if (pstmt->asyn_on != en_Prepare)
{
/* asyn on other */
sqlstat = en_S1010;
}
if (sqlstat != en_00000)
{
PUSHSQLERR (pstmt->herr, sqlstat);
return SQL_ERROR;
}
if (szSqlStr == NULL)
{
PUSHSQLERR (pstmt->herr, en_S1009);
return SQL_ERROR;
}
if (cbSqlStr < 0 && cbSqlStr != SQL_NTS)
{
PUSHSQLERR (pstmt->herr, en_S1090);
return SQL_ERROR;
}
if ((penv->unicode_driver && waMode != 'W')
|| (!penv->unicode_driver && waMode == 'W'))
{
if (waMode != 'W')
{
/* ansi=>unicode*/
_SqlStr = _iodbcdm_conv_var_A2W(pstmt, 0, (SQLCHAR *) szSqlStr, cbSqlStr);
}
else
{
/* unicode=>ansi*/
_SqlStr = _iodbcdm_conv_var_W2A(pstmt, 0, (SQLWCHAR *) szSqlStr, cbSqlStr);
}
szSqlStr = _SqlStr;
cbSqlStr = SQL_NTS;
}
CALL_UDRIVER(pstmt->hdbc, pstmt, retcode, hproc, penv->unicode_driver,
en_Prepare, (
pstmt->dhstmt,
szSqlStr,
cbSqlStr));
if (hproc == SQL_NULL_HPROC)
{
_iodbcdm_FreeStmtVars(pstmt);
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
if (retcode != SQL_STILL_EXECUTING)
_iodbcdm_FreeStmtVars(pstmt);
/* stmt state transition */
if (pstmt->asyn_on == en_Prepare)
{
switch (retcode)
{
case SQL_SUCCESS:
case SQL_SUCCESS_WITH_INFO:
case SQL_ERROR:
pstmt->asyn_on = en_NullProc;
return retcode;
case SQL_STILL_EXECUTING:
default:
return retcode;
}
}
switch (retcode)
{
case SQL_STILL_EXECUTING:
pstmt->asyn_on = en_Prepare;
break;
case SQL_SUCCESS:
case SQL_SUCCESS_WITH_INFO:
pstmt->state = en_stmt_prepared;
pstmt->prep_state = 1;
break;
case SQL_ERROR:
switch (pstmt->state)
{
case en_stmt_prepared:
case en_stmt_executed_with_info:
case en_stmt_executed:
pstmt->state = en_stmt_allocated;
pstmt->prep_state = 0;
break;
default:
break;
}
default:
break;
}
return retcode;
}
static SQLRETURN
SQLSetScrollOptions_Internal (
SQLHSTMT hstmt,
SQLUSMALLINT fConcurrency,
SQLLEN crowKeyset,
SQLUSMALLINT crowRowset)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
HPROC hproc = SQL_NULL_HPROC;
sqlstcode_t sqlstat = en_00000;
SQLRETURN retcode = SQL_SUCCESS;
SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver;
SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver;
for (;;)
{
if (crowRowset == (UWORD) 0)
{
sqlstat = en_S1107;
break;
}
if (crowKeyset > (SDWORD) 0L && crowKeyset < (SDWORD) crowRowset)
{
sqlstat = en_S1107;
break;
}
if (crowKeyset < 1)
{
if (crowKeyset != SQL_SCROLL_FORWARD_ONLY
&& crowKeyset != SQL_SCROLL_STATIC
&& crowKeyset != SQL_SCROLL_KEYSET_DRIVEN
&& crowKeyset != SQL_SCROLL_DYNAMIC)
{
sqlstat = en_S1107;
break;
}
}
if (fConcurrency != SQL_CONCUR_READ_ONLY
&& fConcurrency != SQL_CONCUR_LOCK
&& fConcurrency != SQL_CONCUR_ROWVER
&& fConcurrency != SQL_CONCUR_VALUES)
{
sqlstat = en_S1108;
break;
}
#if (ODBCVER < 0x0300)
if (pstmt->state != en_stmt_allocated)
{
sqlstat = en_S1010;
break;
}
#endif
hproc = _iodbcdm_getproc (pstmt->hdbc, en_SetScrollOptions);
if (dodbc_ver == SQL_OV_ODBC3 && odbc_ver == SQL_OV_ODBC3)
hproc = SQL_NULL_HPROC;
if (hproc != SQL_NULL_HPROC)
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc,
(pstmt->dhstmt, fConcurrency, crowKeyset, crowRowset));
}
else
{
#if (ODBCVER >= 0x0300)
SQLINTEGER InfoValue, InfoType, Value;
HPROC hproc1 = _iodbcdm_getproc (pstmt->hdbc, en_SetStmtAttr);
HPROC hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_GetInfo);
if (hproc1 == SQL_NULL_HPROC || hproc2 == SQL_NULL_HPROC)
{
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
switch (crowKeyset)
{
case SQL_SCROLL_FORWARD_ONLY:
InfoType = SQL_FORWARD_ONLY_CURSOR_ATTRIBUTES2;
Value = SQL_CURSOR_FORWARD_ONLY;
break;
case SQL_SCROLL_STATIC:
InfoType = SQL_STATIC_CURSOR_ATTRIBUTES2;
Value = SQL_CURSOR_STATIC;
break;
case SQL_SCROLL_DYNAMIC:
InfoType = SQL_DYNAMIC_CURSOR_ATTRIBUTES2;
Value = SQL_CURSOR_DYNAMIC;
break;
case SQL_SCROLL_KEYSET_DRIVEN:
default:
InfoType = SQL_KEYSET_CURSOR_ATTRIBUTES2;
Value = SQL_CURSOR_KEYSET_DRIVEN;
break;
}
CALL_DRIVER (pstmt->hdbc, pdbc, retcode, hproc2,
(pdbc->dhdbc, InfoType, &InfoValue, 0, NULL));
if (retcode != SQL_SUCCESS)
{
return retcode;
}
switch (fConcurrency)
{
case SQL_CONCUR_READ_ONLY:
if (!(InfoValue & SQL_CA2_READ_ONLY_CONCURRENCY))
{
PUSHSQLERR (pstmt->herr, en_S1C00);
return SQL_ERROR;
}
break;
case SQL_CONCUR_LOCK:
if (!(InfoValue & SQL_CA2_LOCK_CONCURRENCY))
{
PUSHSQLERR (pstmt->herr, en_S1C00);
return SQL_ERROR;
}
break;
case SQL_CONCUR_ROWVER:
if (!(InfoValue & SQL_CA2_OPT_ROWVER_CONCURRENCY))
{
PUSHSQLERR (pstmt->herr, en_S1C00);
return SQL_ERROR;
}
break;
case SQL_CONCUR_VALUES:
if (!(InfoValue & SQL_CA2_OPT_VALUES_CONCURRENCY))
{
PUSHSQLERR (pstmt->herr, en_S1C00);
return SQL_ERROR;
}
break;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1,
(pstmt->dhstmt, SQL_ATTR_CURSOR_TYPE, Value, 0));
if (retcode != SQL_SUCCESS)
return retcode;
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1,
(pstmt->dhstmt, SQL_ATTR_CONCURRENCY, fConcurrency, 0));
if (retcode != SQL_SUCCESS)
return retcode;
if (crowKeyset > 0)
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1,
(pstmt->dhstmt, SQL_ATTR_KEYSET_SIZE, crowKeyset, 0));
if (retcode != SQL_SUCCESS)
return retcode;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc1,
(pstmt->dhstmt, SQL_ROWSET_SIZE, crowRowset, 0));
if (retcode != SQL_SUCCESS)
return retcode;
#else
sqlstat = en_IM001;
break;
#endif
}
sqlstat = en_00000;
if (1) /* turn off solaris warning message */
break;
}
if (sqlstat != en_00000)
{
PUSHSQLERR (pstmt->herr, sqlstat);
return SQL_ERROR;
}
return retcode;
}
static SQLRETURN
SQLParamOptions_Internal (
SQLHSTMT hstmt,
SQLULEN crow,
SQLULEN * pirow)
{
STMT (pstmt, hstmt);
HPROC hproc2 = SQL_NULL_HPROC;
HPROC hproc3 = SQL_NULL_HPROC;
SQLRETURN retcode;
CONN (pdbc, pstmt->hdbc);
SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver;
SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver;
if (crow == (SQLULEN) 0UL)
{
PUSHSQLERR (pstmt->herr, en_S1107);
return SQL_ERROR;
}
if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc)
{
PUSHSQLERR (pstmt->herr, en_S1010);
return SQL_ERROR;
}
hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_ParamOptions);
#if (ODBCVER >= 0x0300)
hproc3 = _iodbcdm_getproc (pstmt->hdbc, en_SetStmtAttr);
#endif
if (odbc_ver == SQL_OV_ODBC2 &&
( dodbc_ver == SQL_OV_ODBC2
|| (dodbc_ver == SQL_OV_ODBC3 && hproc2 != SQL_NULL_HPROC)))
hproc3 = SQL_NULL_HPROC;
#if (ODBCVER >= 0x0300)
if (hproc3 != SQL_NULL_HPROC)
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3,
(pstmt->dhstmt, SQL_ATTR_PARAMSET_SIZE, crow, 0));
if (SQL_SUCCEEDED (retcode))
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3,
(pstmt->dhstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, pirow, 0));
}
}
else
#endif
{
if (hproc2 == SQL_NULL_HPROC)
{
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc2,
(pstmt->dhstmt, crow, pirow));
}
pstmt->paramset_size = crow;
return retcode;
}
static SQLRETURN
SQLBindParameter_Internal (
SQLHSTMT hstmt,
SQLUSMALLINT ipar,
SQLSMALLINT fParamType,
SQLSMALLINT fCType,
SQLSMALLINT fSqlType,
SQLULEN cbColDef,
SQLSMALLINT ibScale,
SQLPOINTER rgbValue,
SQLLEN cbValueMax,
SQLLEN * pcbValue)
{
STMT (pstmt, hstmt);
CONN (pdbc, pstmt->hdbc);
ENVR (penv, pdbc->henv);
HPROC hproc2 = SQL_NULL_HPROC;
HPROC hproc3 = SQL_NULL_HPROC;
SQLSMALLINT nCType;
SQLSMALLINT nSqlType;
sqlstcode_t sqlstat = en_00000;
SQLRETURN retcode = SQL_SUCCESS;
SQLUINTEGER odbc_ver = ((GENV_t *) pdbc->genv)->odbc_ver;
SQLUINTEGER dodbc_ver = ((ENV_t *) pdbc->henv)->dodbc_ver;
PPARM newparam;
TPARM parm;
int size;
#if (ODBCVER >= 0x0300)
if (0)
#else
/* check param */
if (fSqlType > SQL_TYPE_MAX ||
(fSqlType < SQL_TYPE_MIN && fSqlType > SQL_TYPE_DRIVER_START))
/* Note: SQL_TYPE_DRIVER_START is a negative number
* So, we use ">" */
#endif
{
sqlstat = en_S1004;
}
else if (ipar < 1)
{
sqlstat = en_S1093;
}
else if ((rgbValue == NULL && pcbValue == NULL)
&& fParamType != SQL_PARAM_OUTPUT)
{
sqlstat = en_S1009;
/* This means, I allow output to nowhere
* (i.e. * junk output result). But I can't
* allow input from nowhere.
*/
}
/**********
else if( cbValueMax < 0L && cbValueMax != SQL_SETPARAM_VALUE_MAX )
{
sqlstat = en_S1090;
}
**********/
else if (fParamType != SQL_PARAM_INPUT
&& fParamType != SQL_PARAM_OUTPUT
&& fParamType != SQL_PARAM_INPUT_OUTPUT)
{
sqlstat = en_S1105;
}
else
{
switch (fCType)
{
case SQL_C_DEFAULT:
case SQL_C_BINARY:
case SQL_C_BIT:
case SQL_C_CHAR:
case SQL_C_DATE:
case SQL_C_DOUBLE:
case SQL_C_FLOAT:
case SQL_C_LONG:
case SQL_C_SHORT:
case SQL_C_SLONG:
case SQL_C_SSHORT:
case SQL_C_STINYINT:
case SQL_C_TIME:
case SQL_C_TIMESTAMP:
case SQL_C_TINYINT:
case SQL_C_ULONG:
case SQL_C_USHORT:
case SQL_C_UTINYINT:
#if (ODBCVER >= 0x0300)
case SQL_C_GUID:
case SQL_C_INTERVAL_DAY:
case SQL_C_INTERVAL_DAY_TO_HOUR:
case SQL_C_INTERVAL_DAY_TO_MINUTE:
case SQL_C_INTERVAL_DAY_TO_SECOND:
case SQL_C_INTERVAL_HOUR:
case SQL_C_INTERVAL_HOUR_TO_MINUTE:
case SQL_C_INTERVAL_HOUR_TO_SECOND:
case SQL_C_INTERVAL_MINUTE:
case SQL_C_INTERVAL_MINUTE_TO_SECOND:
case SQL_C_INTERVAL_MONTH:
case SQL_C_INTERVAL_SECOND:
case SQL_C_INTERVAL_YEAR:
case SQL_C_INTERVAL_YEAR_TO_MONTH:
case SQL_C_NUMERIC:
case SQL_C_SBIGINT:
case SQL_C_TYPE_DATE:
case SQL_C_TYPE_TIME:
case SQL_C_TYPE_TIMESTAMP:
case SQL_C_UBIGINT:
case SQL_C_WCHAR:
#endif
break;
default:
sqlstat = en_S1003;
break;
}
}
if (sqlstat != en_00000)
{
PUSHSQLERR (pstmt->herr, sqlstat);
return SQL_ERROR;
}
/* check state */
if (pstmt->state >= en_stmt_needdata || pstmt->asyn_on != en_NullProc)
{
PUSHSQLERR (pstmt->herr, en_S1010);
retcode = SQL_ERROR;
}
/*
* Convert C type to ODBC version of driver
*/
nCType = _iodbcdm_map_c_type (fCType, penv->dodbc_ver);
/*
* Convert SQL type to ODBC version of driver
*/
nSqlType = _iodbcdm_map_sql_type (fSqlType, penv->dodbc_ver);
hproc2 = _iodbcdm_getproc (pstmt->hdbc, en_BindParameter);
#if (ODBCVER >=0x0300)
hproc3 = _iodbcdm_getproc (pstmt->hdbc, en_BindParam);
#endif
parm.pm_par = ipar;
parm.pm_c_type = nCType;
parm.pm_c_type_orig = nCType;
parm.pm_sql_type = fSqlType;
parm.pm_precision = cbColDef;
parm.pm_scale = ibScale;
parm.pm_data = rgbValue;
parm.pm_pOctetLength = pcbValue;
parm.pm_pInd = pcbValue;
parm.pm_size = size;
parm.pm_usage = fParamType;
parm.pm_cbValueMax = cbValueMax;
#if (ODBCVER >=0x0300)
if (fCType == SQL_C_WCHAR && !penv->unicode_driver
&& pcbValue && *pcbValue != SQL_DATA_AT_EXEC)
nCType = SQL_C_CHAR;
#endif
if (ipar < 1 || ipar > STMT_MAX_PARAM)
{
PUSHSQLERR (pstmt->herr, en_S1093);
return SQL_ERROR;
}
if (ipar > pstmt->st_nparam)
{
size_t newsize = ipar + 10;
if (newsize > STMT_MAX_PARAM)
newsize = STMT_MAX_PARAM;
if ((newparam = calloc (newsize, sizeof (TPARM))) == NULL)
{
PUSHSQLERR (pstmt->herr, en_S1001);
return SQL_ERROR;
}
if (pstmt->st_pparam)
{
memcpy (newparam, pstmt->st_pparam, pstmt->st_nparam * sizeof (TPARM));
free (pstmt->st_pparam);
}
pstmt->st_pparam = newparam;
pstmt->st_nparam = (u_short) newsize;
}
pstmt->st_pparam[ipar-1] = parm;
if (odbc_ver == SQL_OV_ODBC2 &&
( dodbc_ver == SQL_OV_ODBC2
|| (dodbc_ver == SQL_OV_ODBC3 && hproc2 != SQL_NULL_HPROC)))
hproc3 = SQL_NULL_HPROC;
#if (ODBCVER >=0x0300)
if (fParamType == SQL_PARAM_INPUT && hproc3 != SQL_NULL_HPROC)
{
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc3,
(pstmt->dhstmt, ipar, nCType, nSqlType, cbColDef,
ibScale, rgbValue, pcbValue));
}
else
#endif
{
if (hproc2 == SQL_NULL_HPROC)
{
PUSHSQLERR (pstmt->herr, en_IM001);
return SQL_ERROR;
}
CALL_DRIVER (pstmt->hdbc, pstmt, retcode, hproc2,
(pstmt->dhstmt, ipar, fParamType, nCType, nSqlType, cbColDef,
ibScale, rgbValue, cbValueMax, pcbValue));
}
return retcode;
}
