oracle应用怎么写,oracle函数怎么写

oracle 主备切换 应用需要怎么写

主库增加一个浮动IP，这个IP是应用连接的地址。 dg主备如果发生切换的话，这个浮动IP也跟着切换（自己写shell脚本了）

目前累计服务客户上千家，积累了丰富的产品开发及服务经验。以网站设计水平和技术实力，树立企业形象，为客户提供成都网站建设、成都网站设计、网站策划、网页设计、网络营销、VI设计、网站改版、漏洞修补等服务。成都创新互联始终以务实、诚信为根本，不断创新和提高建站品质，通过对领先技术的掌握、对创意设计的研究、对客户形象的视觉传递、对应用系统的结合，为客户提供更好的一站式互联网解决方案，携手广大客户，共同发展进步。

怎样使用OCI编写多线程的ORACLE应用软件

void* OracleProcess(GPS_DATA GpsRec) // 数据库数据处理

{

interval = 0;

struct HashItem* pHash;

pHash = inithashtable(MAX_REC2);

char sql[384] = {0};

char temp[256] = {0};

char tName[10] = {0}; // 表名字

int i,k;

int j = TotalRec RATE;

double distance;

for(i=0; i j; i++)

{

sprintf(temp,"%s%f%f%f%d",gps_last[i].tid,gps_last[i].lon,gps_last[i].lat,gps_last[i].speed,gps_last[i].udate);

InsertHash(temp, pHash, MAX_REC2); // 插入最后GPS信息到hash

memset(temp,0x00,256);

}

for(i = 0; i TotalRec; i++)

{

for(k=0; kj; k++) // 查询车机是否在册

if(strcmp(GpsRec[i].tid,tid[k]) == 0)

break;

if(k j)

{

if(GpsRec[i].udate != 0.00)

{

distance = InfoUpdate(GpsRec,i); // 最新GPS数据更新

sprintf(temp,"%s%f%f%f%d",GpsRec[i].tid,GpsRec[i].lon,GpsRec[i].lat,GpsRec[i].speed,GpsRec[i].udate);

if(GetHashTablePos(temp, pHash, MAX_REC2) == -1) // 查找hash是否存在

{

if (distance 0.0001)

{

sprintf(tName,"GPS_%d_Y",tf[k]);

InsertHash(temp, pHash, MAX_REC2); // 插入

sprintf(sql,"insert into %s (id,tm_id,lon,lat, speed, utc_time, udate,mileage,DIRECTION,DISTANCE) values (seq_gps.nextVal,'%s','%f','%f','%f','%d','%d','%f','%d','%f','%d')",

tName,GpsRec[i].tid,GpsRec[i].lon,GpsRec[i].lat,GpsRec[i].speed,GpsRec[i].utime,GpsRec[i].udate,GpsRec[i].mileage,GpsRec[i].dir,distance,interval);

printf("%s\n",sql);

oci_excu(oracle_env,(text *)sql,0); // 插入数据

memset(tName,0x00,10);

}

}

memset(sql,0x00,384);

memset(temp,0x00,256);

}

}

}

memset(GpsRec,0x00,sizeof(GpsRec));

free(pHash);

pthread_exit(NULL);

}

void TcpProcess(int tfd) // 处理TCP连接上的事务

{

struct timeval ntime;

int index = 0,times,ret;

int rlen = 0,rflag = 0;

char recvbuf[513] = {0};

bzero(recvbuf,513);

while(1)

{

ret = rlen = read(tfd,recvbuf,512);

if(rlen = 0)

break;

if((rlen%32) == 0) // 32长度为标准TCP信息

{

times = 0;

ret = 5;

while(ret--)

{

if(tflag[tfd] == tfd) // 已经存在的socket

{

LOVENIX *info = (LOVENIX *)malloc(sizeof(LOVENIX));

memset(info,0x00,sizeof(LOVENIX));

if(recvbuf[times] == 0x58 || recvbuf[times] == 0x59)

ProtocolAnalysisLovenixTcp(recvbuf[times],info);

else if(recvbuf[times] == 0x24)

ProtocolAnalysisLovenixUdp(recvbuf[times],info);

sprintf(info-tid,"%s",seq[tfd]); // 合成车辆ID

DataProcess(info); // 处理GPS数据

free(info);

gettimeofday(ntime, NULL);

cntime[tfd] = ntime.tv_sec; // 更新时间

times += 32;

}

}

}

else if(rlen 32)

{

if(!rflag)

{

if((index = RegLovenix(tfd,recvbuf)) -1)

{

sprintf(seq[tfd],"%s",tid[index]); // 将对应的socket设备ID保存

gettimeofday(ntime, NULL);

sfd[tfd] = tfd;

cntime[tfd] = ntime.tv_sec;

tflag[tfd] = tfd;

rflag = 1;

}

}

}

if(rlen 512); // 已经读完

break;

memset(recvbuf,0x00,rlen);

}

}

void *TcpServer(void *arg)

{

int port = (unsigned int) arg;

int efd,i;

struct timeval ntime;

int listener, nfds, n, listen_opt = 1, lisnum;

struct sockaddr_in my_addr, their_addr;

socklen_t len = sizeof(their_addr);

lisnum = MAXLISTEN;

for(i=0; iMAX_REC; i++)

{

sfd[i] = 0;

tflag[i] = 0;

}

if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) // 开启 socket 监听

{

lprintf(lfd, FATAL, "TCP Socket error!\n");

exit(1);

}

else

lprintf(lfd, INFO, "TCP socket creat susscess！\n");

setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (void *) listen_opt,(int) sizeof(listen_opt)); // 设置端口多重邦定

setnonblocking(listener);

bzero(my_addr, sizeof(my_addr));

my_addr.sin_family = PF_INET;

my_addr.sin_port = htons(port);

my_addr.sin_addr.s_addr = INADDR_ANY;

if (bind(listener, (struct sockaddr *) my_addr, sizeof(struct sockaddr)) == -1)

{

lprintf(lfd, FATAL, "TCP bind error!\n");

exit(1);

}

else

lprintf(lfd, INFO, "TCP bind susscess!\n");

if (listen(listener, lisnum) == -1)

{

lprintf(lfd, FATAL, "TCP listen error!\n");

exit(1);

}

else

lprintf(lfd, INFO, "TCP listen susscess!\n");

kdpfd = epoll_create(MAXEPOLLSIZE); // 创建 epoll句柄，把监听socket加入到epoll集合里

ev.events = EPOLLIN | EPOLLET; // 注册epoll 事件

ev.data.fd = listener;

if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, listener, ev) 0)

lprintf(lfd, FATAL, "EPOLL_CTL_ADD error!\n");

while (1)

{

sem_wait(sem_tcp); // 等待 sem_TCP

sem_wait(sem_tp); // 将tp值减一

nfds = epoll_wait(kdpfd, events, MAXEPOLLSIZE, 1); // 等待有事件发生

if (nfds == -1)

lprintf(lfd, FATAL,"EPOLL_WAIT error!\n");

for (n = 0; n nfds; ++n) // 处理epoll所有事件

{

if (events[n].data.fd == listener) // 如果是连接事件

{

if ((efd = accept(listener, (struct sockaddr *) their_addr,len)) 0)

{

lprintf(lfd, FATAL, "accept error!\n");

continue;

}

else

lprintf(lfd, INFO, "Client from ：%s\tSocket ID:%d\n", inet_ntoa(their_addr.sin_addr) ,efd);

setnonblocking(efd); // 设置新连接为非阻塞模式

ev.events = EPOLLIN | EPOLLET; // 注册新连接

ev.data.fd = efd;

if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, efd, ev) 0) // 将新连接加入EPOLL的监听队列

lprintf(lfd, FATAL, "EPOLL_CTL_ADD error!\n");

else

{

gettimeofday(ntime, NULL);

cntime[efd] = ntime.tv_sec;

sfd[efd] = efd;

}

}

else if (events[n].events EPOLLIN)

tpool_add_work(pool, TcpProcess, (void*)events[n].data.fd); // 读取分析TCP信息

else

{

close(events[n].data.fd);

epoll_ctl(kdpfd, EPOLL_CTL_DEL, events[n].data.fd, ev);

}

}

sem_post(sem_cm);

sem_post(sem_udp);

}

close(listener);

}

int DataProcess(LOVENIX *info) // 处理GPS数据

{

if(sflag == 0 (CacheRec != TotalRec)) // 缓存1可用且没有满

{

gps_cache[CacheRec].lat = info-lat;

gps_cache[CacheRec].mileage = info-mileage;

gps_cache[CacheRec].lon = info-lon;

gps_cache[CacheRec].speed = atod(info-speed, strlen(info-speed))*0.514444444*3.6;

gps_cache[CacheRec].udate = atoi(info-udate);

gps_cache[CacheRec].utime = atoi(info-utime);

gps_cache[CacheRec].dir = atoi(info-dir);

sprintf(gps_cache[CacheRec].tid ,"%s",info-tid);

CacheRec++;

// printf("CacheRec %d\tTotalRec %d \t sflag:%d\n",CacheRec,TotalRec,sflag);

if(CacheRec == TotalRec)

{

sflag = 1;

pthread_attr_init(attr); // 初始化属性值，均设为默认值

pthread_attr_setscope(attr, PTHREAD_SCOPE_SYSTEM);

pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED); // 设置线程为分离属性

if (pthread_create(thread, attr,(void*) OracleProcess,(void*)gps_cache)) // 创建数据处理线程

lprintf(lfd, FATAL, "oracle pthread_creat error!\n");

CacheRec = 0;

}

}

else if(sflag == 1 (Cache1Rec != TotalRec)) // 缓存2可用且没有满

{

gps_cache1[Cache1Rec].mileage = info-mileage;

gps_cache1[Cache1Rec].lat = info-lat;

gps_cache1[Cache1Rec].lon = info-lon;

gps_cache1[Cache1Rec].speed = atod(info-speed, strlen(info-speed))*0.514444444*3.6;

gps_cache1[Cache1Rec].udate = atoi(info-udate);

gps_cache1[Cache1Rec].utime = atoi(info-utime);

gps_cache1[Cache1Rec].dir = atoi(info-dir);

sprintf(gps_cache1[Cache1Rec].tid ,"%s",info-tid);

Cache1Rec++;

if(Cache1Rec == TotalRec)

{

sflag = 0;

pthread_attr_init(attr); // 初始化属性值，均设为默认值

pthread_attr_setscope(attr, PTHREAD_SCOPE_SYSTEM);

pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED); // 设置线程为分离属性

if (pthread_create(thread, attr,(void*) OracleProcess,(void*)gps_cache1)) // 创建数据处理线程

lprintf(lfd, FATAL, "oracle pthread_creat error!\n");

Cache1Rec = 0;

}

}

else

{

lprintf(lfd, FATAL, "No cache to use!\n");

return (0);

}

return (1);

}

oracle 应用

第一章 ORACLE介绍

由于ORACLE数据库产品是当前数据库技术的典型代表，她的产品除了数据库系统外，还有应用系统、开发工具等。刚接触Oracle的人员都有这样的感觉：Oracle的产品太多，每个产品内容精深，不知道从哪儿开始学才好。为了用少量时间更好地理解和使用oracle 数据库系统，有必要对oracle的一些基本术语及概念进行了解，下面给出一些在管理中经常用到的概念和术语，供初学者快速了解Oracle数据库系统提供方便。

§1.1 ORACLE7和ORACLE8

ORACLE7是一种完全的关系数据库系统，它不支持面向对象。

ORACLE8 则是一个引入面向对象的数据库系统，它既非纯的面向对象的数据库也非纯的关系数据库，它是两者的结合，因此叫做“对象关系数据库”。

§1.2 ORACLE8 特点

ORACLE8 于 1997年6月正式发布，它包括了几乎所有的数据库技术，因此被认为是未来企业级主选数据库之一。主要有以下特点：

1.对象/关系模型

ORACLE8对于对象模型采取较为现实和谨慎的态度，使用了对象/关系模型，即在完全支持传统关系模型的基础上，为对象机制提供了有限的支持。ORACLE8不仅能够处理传统的表结构信息，而且能够管理由C++，Smalltalk 以及其它开发工具生成的多媒体数据类型，如文本，视频，图形，空间对向等。这种做法允许现有软件开发产品与工具软件及ORACLE8应用软件共存，保护了客户的投资。

2.数据库服务器系统的动态可伸缩性

ORACLE8引入了连接存储池(connection polling)和多路复用（multiplexing）机制，提供了对大型对象的支持。当需要支持一些特殊数据类型时，用户可以创建软件插件（catridge ）来实现。ORACLE8采用了高级网络技术，提高共享池和连接管理器来提高系统的可括性，容量可从几 GB 到 几百 TB 字节，可允许10万用户同时并行访问，ORACLE 的数据库中每个表可以容纳 1000列，能满足目前数据库及数据仓库应用的需要。

ORACLE 公司称，ORACLE8可以支持达 512PB的数据量。但目前还未有哪一家用户的数据库的数据量达到这个数量。下面是几种常用数据量的等价关系：

1MB = 1024 KB

1GB = 1Gigabyte Byte = 1024 MB

1TB = 1TeraByte = 1024 GB = 1024*1024MB

1PB = 1PeraByte = 1024 TB = 1024 * 1024 * 1024 MB

1EB = 1ExaByte = 1024 PB = 1024 * 1024 *1024 *1024 MB

.....................................