/*
* mylinkedlist.c
*
* Created on: Dec 29, 2018
* Author: gjw
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "mylinkedlist.h"
struct NODE {
ADT data;
int size;
PNODE next;
PNODE previous;
} ;
typedef struct NODE NODE;
struct MylinkedListS {
unsigned int len;
PNODE head, tail;
};
MylinkedList* MyCreateList() {
MylinkedList* list = (MylinkedList*) malloc(sizeof(MylinkedList));
PNODE head = (NODE *) malloc(sizeof(NODE));
PNODE tail = (NODE *) malloc(sizeof(NODE));
list->head = head;
list->tail = tail;
list->tail->next=NULL;
list->tail->previous=NULL;
list->head->next=NULL;
list->head->previous=NULL;
list->len=0;
printf("init a list");
return list;
}
void MyAppend(MYLINKEDLIST list, ADT data,int len) {
if (list->head->next == NULL) {
MyInsert(list, data, 0,len);
return;
}
printf("->");
PNODE ctail = (NODE *) malloc(sizeof(NODE));
ctail->data=(char *)malloc(len);
memcpy(ctail->data,data,len);
ctail->size=len;
ctail->next=NULL;
ctail->previous=list->tail->next;
list->tail->next->next = ctail;
list->tail->next = ctail;
list->len = list->len + 1;
}
int MyInsert(MYLINKEDLIST list, ADT data, unsigned int pos,int len) {
if ( pos > list->len) return 0;
printf("insert success!\n");
PNODE node = list->head;
for (unsigned int i = 0; i < pos; i++) {
node = node->next;
}
PNODE newNode = (NODE *) malloc(sizeof(NODE));
newNode->data=(char *)malloc(len);
memcpy(newNode->data,data,len);
newNode->size=len;
newNode->next = node->next;
newNode->previous=node; if(node->next){
newNode->next->previous=newNode;
}
node->next = newNode;
list->tail->next=newNode;
list->len = list->len + 1;
return 1;
}
ADT Myrpop(MYLINKEDLIST list,int * sz){
PNODE tail=list->tail->next;
if(list->len==0){
return NULL;
}
ADT data=tail->data;
*sz=tail->size; list->tail->next=tail->previous;
tail->previous->next=NULL;
list->len=list->len-1;
free(tail);
return data;
}int MyLength(MYLINKEDLIST list) {
return list->len;
}
int MyIsEmpty(MYLINKEDLIST list) {
return !list->len;
}
void getData(PNODE n,char ** data,int * sz) {
*data=n->data;
*sz=n->size;
}
PNODE MyNext(PNODE node) {
return node->next;
}
PNODE MyIndex(MYLINKEDLIST list,unsigned int index){
PNODE n=list->head->next;
if(index>=list->len){
return NULL;
}
for(int i=0;i<index;i++){
n=n->next;
}
return n;
}
int Mylset(MYLINKEDLIST list, ADT data, unsigned int pos,int len) {
PNODE node=list->head->next;
if(list->len==0){
MyInsert(list,data,pos,len);
return 1;
}
if(pos>=list->len){
return 0;
} for(int i=0;i<pos;i++){
node=node->next;
}
realloc(node->data,len);
node->size=len;
memcpy(node->data,data,len);
return 1;
}
//added by guojiangweivoid myrpushCommand(client *c){
int j, pushed = 0;
robj *lobj = lookupKeyWrite(c->db,c->argv[1]);
for (j = 2; j < c->argc; j++) {
if (!lobj) {
lobj = createMylistObject();
dbAdd(c->db,c->argv[1],lobj);
}
MyAppend(lobj->ptr,c->argv[j]->ptr,sdslen(c->argv[j]->ptr));
pushed++;
}
addReplyLongLong(c, MyLength(lobj->ptr)); if (pushed) {
char *event = "rpush";
signalModifiedKey(c->db,c->argv[1]);
notifyKeyspaceEvent(1,event,c->argv[1],c->db->id);
}
server.dirty += pushed;
}
void mylrangeCommand(client *c){
robj *o;
long start, end, llen, rangelen;
char * data;
int sz;
if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != C_OK) ||
(getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != C_OK)) return;
if ((o = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk)) == NULL
|| checkType(c,o,MYOBJ_LIST)) return;
llen = MyLength(o->ptr); /* convert negative indexes */
if (start < 0) start = llen+start;
if (end < 0) end = llen+end;
if (start < 0) start = 0;
/* Invariant: start >= 0, so this test will be true when end < 0.
* The range is empty when start > end or start >= length. */
if (start > end || start >= llen) {
addReply(c,shared.emptymultibulk);
return;
} if (end >= llen) end = llen-1;
rangelen = (end-start)+1; /* Return the result in form of a multi-bulk reply */
addReplyMultiBulkLen(c,rangelen);
if (o->encoding == OBJ_ENCODING_QUICKLIST) {
PNODE n = MyIndex(o->ptr, start);
while(rangelen--) {
getData( n,&data,&sz);
addReplyBulkCBuffer(c,data,sz);
n=MyNext(n);
}
} else {
serverPanic("List encoding is not QUICKLIST!");
}
}
void myrpopCommand(client *c){
robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk);
int sz;
if (o == NULL || checkType(c,o,MYOBJ_LIST)) return;
char * data=Myrpop(o->ptr,&sz);
robj *value = createStringObject(data,sz);
free(data); if (value == NULL) {
addReply(c,shared.nullbulk);
} else {
char *event = "rpop";
addReplyBulk(c,value);
decrRefCount(value);
notifyKeyspaceEvent(NOTIFY_LIST,event,c->argv[1],c->db->id);
if (listTypeLength(o) == 0) {
notifyKeyspaceEvent(NOTIFY_GENERIC,"del", c->argv[1],c->db->id);
dbDelete(c->db,c->argv[1]);
} signalModifiedKey(c->db,c->argv[1]);
server.dirty++;
}
}
void myllenCommand(client *c){
robj *o = lookupKeyReadOrReply(c,c->argv[1],shared.czero);
if (o == NULL || checkType(c,o,MYOBJ_LIST)) return;
addReplyLongLong(c,MyLength(o->ptr));
}
void mylsetCommand(client *c){
robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
if (o == NULL || checkType(c,o,MYOBJ_LIST)) return;
long index;
robj *value = c->argv[3];
if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
return;
if (o->encoding == OBJ_ENCODING_QUICKLIST) {
MYLINKEDLIST ql = o->ptr;
int replaced = Mylset(ql,value->ptr, index,sdslen(value->ptr));
if (!replaced) {
addReply(c,shared.outofrangeerr);
} else {
addReply(c,shared.ok);
signalModifiedKey(c->db,c->argv[1]);
notifyKeyspaceEvent(NOTIFY_LIST,"lset",c->argv[1],c->db->id);
server.dirty++;
}
} else {
serverPanic("Unknown list encoding");
}
}
void mylinsertCommand(client *c){
long index;
robj *subject;
int inserted = 0;
if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK)){
addReply(c,shared.syntaxerr);
return;
}
if ((subject = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
checkType(c,subject,MYOBJ_LIST)) return;
inserted=MyInsert(subject->ptr,c->argv[3]->ptr,index,sdslen(c->argv[3]->ptr));
if (inserted) {
signalModifiedKey(c->db,c->argv[1]);
notifyKeyspaceEvent(NOTIFY_LIST,"linsert", c->argv[1],c->db->id);
server.dirty++;
} else { /* Notify client of a failed insert */
addReply(c,shared.cnegone);
return;
} addReplyLongLong(c,MyLength(subject->ptr));
}
void mylindexCommand(client *c){
long index;
int size;
robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
if (o == NULL || checkType(c,o,MYOBJ_LIST)) return;
if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != C_OK))
return;
PNODE n=MyIndex(o->ptr,index);
if(n==NULL){
addReply(c,shared.nullbulk);
return;
}
char *data;
getData( n,&data,&size);
if (o->encoding == OBJ_ENCODING_QUICKLIST) {
if (data) {
robj *value=createStringObject(data,size);
addReplyBulk(c,value);
decrRefCount(value);
} else {
addReply(c,shared.nullbulk);
}
} else {
serverPanic("Unknown list encoding");
}
}
alect是告诉数据库我连接的是MySQL，请在生成SQL语句或者其他操作时，按照MySQL的语法来执行；
current_session_context_class是hibernate的事务管理方式，即每个线程代表一个事务；
show_sql为true时，是配置了在控制台打印生成的SQL语句；
hbm2ddl.auto这个配置代表自动更新表结构，也就是hibernate可以自动的在数据库中创建表。无需自行创建。
mapping resource指向了实体类与数据库字段做映射的配置文件路径。
③src下新建pojo包，创建实体类Hero.java，设置name和id属性，并给出get、set方法；
④src下新建hibernate文件夹，创建Hero.hbm.xml文件
<?xml version="1.0" encoding="UTF-8"?> package指向的是该实体类所在的包，以src为根目录。
标签即代表一个映射类。在该标签属性中，name属性是对应的package包下的需要进行映射的实体类，table对象数据库中的表名。
在class标签中，必须设置，因为他声明了该表的主键对应实体的那个属性。name是属性名，column代表对应哪个字段，该配置是说该id的增长方式按照配置的数据库的增长方式来(例如数据库中没有该表，则hibernate会创建这个表，并设置id为主键，设置为自增长)
该标签是配置除主键外其他的属性与字段的映射关系，name是属性，column是字段。
⑤src下新建action包，创建Test.java文件
public class Test {
public static void main(String[] args) {
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session s = sf.openSession();
s.beginTransaction();
Hero hero = new Hero();
hero.setName(“女警”);
s.save(hero);
s.getTransaction().commit();
s.close();
sf.close();
}
}
此时，右键运行该文件，则数据库中会生成hero表，并插入了一条数据。一套完整的hibernate配置搭建就完成了并能够成功运行。此时就能够感受到，hibernate的面向对象的思想，通过操作对象的方式完成对数据的持久化。似不似很方便了。
二：增删改查
对象在hibernate中的三种状态：瞬时、持久、托管。
当对象被new创建，并设置了属性值，没有跟hibernate发生任何关系，JVM停止运行，该对象就烟消云散。此时为瞬时状态
该对象与hibernate发生了关系，并且有对象的session，在数据库中有对应的记录，且该对象存在session的缓存中。则该对象为持久化状态。
该对象在数据库中有对应的一条记录，但是session被关闭了，该对象不存在session的缓存中了。对象不能跟数据库进行通讯，它恢复成了一个普通的对象了。此时为托管状态。例如通过session的get方法获取到id为1的hero对象，然后session关闭了，hero对象虽然有个数据库查询出来的值，但它此时仅仅是一个hero对象，修改它与数据库没有任何关系了。
对于session对象来讲，他就是代表一次程序与数据库的对象，当它开启后，相当于设置了映射关系的对象就可以与数据库进行通讯，通过修改对象完成对数据库的操作。此时对象就是处于持久化的状态。当session关闭后，通讯切断。程序恢复正常。
通过hibernate完成数据库的操作过程中，大多可遵循以下顺序：
创建sessionFactory, 通过sessionFactory打卡一个session对象，该session
---------------------