dbfilter.c

bonddb 是一个源于PostgreSQL封装包的对象。它是一个由C/C++编写的快速数据提取层应用软件

            {
            warningmsg("Failed to extract field %s of table %s",
				request->fieldname, request->tablename);
            break;
            }
			if (request->fieldpos >= 0)
				obj->currentcache->flags[request->fieldpos] = (gint)request->flags;
         }
      }
   obj->filtered = FALSE;
   if (db_moveto(obj, origrow) != 0)
      {
      warningmsg("Unable to move to the orginal record.");
      return -3;
      }
   obj->filtered = TRUE;

   return 0;
   }

/**
 * db_filter_addrequestlist:
 * 
 * Use in the format retlist = db_filter_addrequest(retlist,"fieldname","tablename");
 * Will add a desired field to the cache, which could be filtered on.  This is
 * useful for speeding up load times.
 */
GList *
db_filter_addrequestlist(GList * requestlist, gchar * fieldname, gchar * tablename)
   {
   DbFilterAppend *request;

   request = (DbFilterAppend *) mem_alloc(sizeof(DbFilterAppend));
   memset(request, 0, sizeof(DbFilterAppend));
   request->tablename = tablename;
   request->fieldname = fieldname;
   request->flags = FILTER_SHOW;
	request->fieldpos = -1;
   requestlist = g_list_append(requestlist, request);
   return requestlist;
   }

/**
 * db_filter_addrequestlist:
 * 
 * 
 * 
 */
GList *
db_filter_addrequestlist_hidden(GList * requestlist, gchar * fieldname, gchar * tablename)
   {
   DbFilterAppend *request;

   request = (DbFilterAppend *) mem_alloc(sizeof(DbFilterAppend));
   memset(request, 0, sizeof(DbFilterAppend));
   request->tablename = tablename;
   request->fieldname = fieldname;
   request->flags = FILTER_HIDDEN;
	request->fieldpos = -1;
   requestlist = g_list_append(requestlist, request);
   return requestlist;
   }

/**
 * db_filter_clear:
 *
 * Reshow all variables and unfilter everything.
 * 
 */

gint
db_filter_clear(Object * obj)
   {
   int i;

   for (i = 0; i < obj->numcache; i++)
		if (obj->cache[i] != NULL)
			{
			obj->cache[i]->filter->sortedpos = obj->cache[i]->origrow;
			obj->cache[i]->filter->active = TRUE;
			}
   return 0;
   }

/**
 * db_filter_movepos:
 * @obj: 
 * 
 * Works out what position to move to
 */

gint
db_filter_moveto(Object * obj, gint row)
   {
   gint i;

   g_assert(obj);
	   
	   
   /* g_assert(row >=0 && row < obj->num); */
   /* Francis: Make more harsh check */
   /* removed by dru cause it breaks stuff */
   /*g_assert(obj->filtered == TRUE &&
	   row >= 0 && row < obj->num); */
	   
   if (obj->filtered == FALSE)
      {
      debugmsg("no filter present");
      return row;
      }
   if (row < 0)
      {
      warningmsg("invalid row to move to");
      return -1;
      }
   for (i = 0; i < obj->numcache; i++)
      {
      if (obj->cache[i]->filter->sortedpos == row)
         {
         obj->currentcache = obj->cache[i];
		//debugwin ("For asking row %d, true cache pos: %d. Origrow: %d", row, i, obj->cache[i]->origrow);
	 /* m.essage("returning pos %d for row %d, i=%d",obj->cache[i]->filter->sortedpos,row,i); */
         return obj->cache[i]->origrow;
         }
      }
   warningmsg("unable to move to position %d", row);
	g_assert(NULL);
   return -2;
   }

gint
db_filter_num(Object * obj)
   {
   gint i, num = 0;
	g_assert(obj);

   if (obj->filtered == FALSE)
      return obj->num;
   for (i = 0; i < obj->numcache; i++) {
      if (obj->cache[i]->filter->active == TRUE) {
         num++;
	  }
   }
   return num;
   }

/**
 * db_filter_removefilter:
 * 
 * Removes filtering completely from the list.  All records would have to be
 * reloaded inorder to get filtering back.
 */
void
db_filter_removefilter(Object * obj)
   {
   obj->filtered = FALSE;

   }

/**
 * db_filter_getatpos:
 * @obj:
 * @pos:
 * 
 * 
 */
gchar *
db_filter_getatpos(Object * obj, gint pos)
   {
   g_assert(obj);
   if (obj->currentcache == NULL)
      return NULL;
   if (pos < 0 || pos >= obj->currentcache->num)
      {
      errormsg("invalid pos of %d", pos);
      return NULL;
      }
   return obj->currentcache->value[pos];
   }

/**
 * db_filter_checkvisible:
 *
 * Not written yet.
 */
gint
db_filter_checkvisible(Object * obj)
   {
   return 0;
   }
/**
 * db_filter_setfilterstate:
 * 
 * set the state on the object filtering
 */
void
db_filter_setfilterstate(Object *obj, gboolean state)
	{
	g_assert(obj);
	obj->filtered = state;
	}

gint
db_filter_resort(Object *obj, gint pos)
	{
	gint retval=0;
	GList *walk;
	DbFilterAppend *fa;

	if (obj->filtered == TRUE)
		db_filter_setfilterstate(obj,FALSE);
	if (obj->filterapplied == NULL)
		{
		warningmsg("no filter applied. can't do this");
		return -1;
		}
	obj->filterapplied->internalaction = 1;
	retval -= db_filter_load(obj, obj->filterapplied->requestlist);
	for(walk=g_list_first(obj->filterapplied->filters);walk!=NULL;walk=walk->next)
		{
		fa = walk->data;
		retval -= db_filter_filterbyvalue(obj, fa->fieldname, fa->tablename, fa->value);
		}	
	obj->filterapplied->internalaction = 0;
	return retval;
	}
/**
 * db_filter_freeapplied:
 * 
 * Free the applied filters list on an object.
 *  
 */
void
db_filter_freeapplied(Object *obj)
{
	DbFilterAppend *fa;
	GList *walk;
	if (obj->filterapplied!=NULL)
		{
		/* free filters */
		for (walk=g_list_first(obj->filterapplied->filters);walk!=NULL;walk=walk->next)
			{
			fa = walk->data;
			mem_free(fa->fieldname);
			mem_free(fa->tablename);
			mem_free(fa->value);
			mem_free(fa);			
			}
		g_list_free(obj->filterapplied->filters);
		/* free list of request fields to display */
		db_filter_freerequest(g_list_first(obj->filterapplied->requestlist));
		mem_free(obj->filterapplied);
		}
	obj->filterapplied = NULL;
}
/**
 * db_filter_applied_addrequest:
 * 
 * Copy the requestlist onto an object for future reference
 * 
 */
void
db_filter_applied_addrequest(Object *obj,GList *requestlist)
	{
	g_assert(obj);
	if (obj->filterapplied == NULL)
		{
		obj->filterapplied = mem_alloc(sizeof(DbFilterApplied));
		memset(obj->filterapplied,0,sizeof(DbFilterApplied));
		}
	if (obj->filterapplied->internalaction == 1)
		return;

   if (requestlist == obj->filterapplied->requestlist)
		return;
	else
	if (obj->filterapplied->requestlist != NULL)
		db_filter_freerequest(g_list_first(obj->filterapplied->requestlist));

	obj->filterapplied->requestlist = requestlist;
	}
/**
 * db_filter_applied_addfilter:
 * @obj: database object
 * @field: 
 * @table:
 * @value:
 *
 * 
 */
void
db_filter_applied_addfilter(Object *obj,gchar *field, gchar *table, gchar *value)
	{
	DbFilterAppend *fa;
	g_assert(obj);
	if (obj->filterapplied == NULL)
		{
		obj->filterapplied = mem_alloc(sizeof(DbFilterApplied));
		memset(obj->filterapplied,0,sizeof(DbFilterApplied));
		}
	if (obj->filterapplied->internalaction == 1)
		return;

	fa = (DbFilterAppend*)mem_alloc(sizeof(DbFilterAppend));
	memset(fa,0,sizeof(DbFilterAppend));
	fa->fieldname = mem_strdup(field);
	fa->tablename = mem_strdup(table);
	fa->value = mem_strdup(value);
	obj->filterapplied->filters = g_list_append(obj->filterapplied->filters,fa);
	}

/**
 * db_filter_getrowinfilter:
 * 
 * Work out what position you are in a filtered object.  
 * 
 */
gint
db_filter_getrowposinfilter(Object *obj, gint *row)
	{
	gint i, count=0;
	g_assert(obj);
	*row = -1;
	for (i=0;i<obj->numcache;i++)
		{
		if (obj->cache[i]->filter->active == FALSE)
			continue;
		if (obj->row == obj->cache[i]->origrow)
			{
			*row = count;
			return 0;
			}
		count++;
		}
	return -1;
	}

/**
 * db_filter_deletedrow:
 * @obj: Database object
 * @row: Old row pos that was deleted, and filter needs to be updated around it.
 * 
 * Resort the cache list to accommidate a deleted record.
 */
gint
db_filter_deletedrow(Object *obj, gint row)
	{
	gint i, oldpos = 0;
	g_assert(obj);
	if (obj->filtered == FALSE)
		return 1;
	if (row >= 0 && row <= obj->numcache)
		oldpos = obj->cache[row]->filter->sortedpos;
	else
		return -1;
	/* m.essage("deleting row %d, oldpos %d",row,oldpos); */
	for (i=0;i<obj->numcache;i++)
		if (obj->cache[i] != NULL)
			if (obj->cache[i]->filter->sortedpos >= oldpos)
				obj->cache[i]->filter->sortedpos = obj->cache[i]->filter->sortedpos - 1;
	obj->cache[row]->filter->sortedpos = -1;
	obj->cache[row]->filter->active = FALSE;
	return 0;
	}