sql_parser.c

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

   char *retval;

   if (!cond)
      return NULL;
   switch (cond->op)
      {
   case SQL_eq:
   case SQL_is:
   case SQL_not:
   case SQL_in:
   case SQL_notin:
   case SQL_like:
      retval = memsql_strappend_free(sql_field_stringify(cond->d.pair.left), memsql_strdup(" "));
      retval = memsql_strappend_free(retval, sql_condition_op_stringify(cond->op));
      retval = memsql_strappend_free(retval, memsql_strdup(" "));
      retval = memsql_strappend_free(retval, sql_field_stringify(cond->d.pair.right));
      break;

   case SQL_between:
      retval = memsql_strappend_free(sql_field_stringify(cond->d.between.field), memsql_strdup(" between "));
      retval = memsql_strappend_free(retval, sql_field_stringify(cond->d.between.lower));
      retval = memsql_strappend_free(retval, memsql_strdup(" and "));
      retval = memsql_strappend_free(retval, sql_field_stringify(cond->d.between.upper));
      break;

   default:
      fprintf(stderr, "Invalid  condition type: %d\n", cond->op);
      retval = NULL;
      }

   return retval;
   }

static char *
sql_table_stringify(sql_table * table)
   {
   char *retval;

   if (!table)
      return NULL;

   switch (table->type)
      {
   case SQL_simple:
      retval = memsql_strdup(table->d.simple);
      break;

   case SQL_join:
      retval = memsql_strappend_free(sql_table_stringify(table->d.join.left), memsql_strdup(" join "));
      retval = memsql_strappend_free(retval, sql_table_stringify(table->d.join.right));
      if (table->d.join.cond)
         {
         retval = memsql_strappend_free(retval, memsql_strdup(" on "));
         retval = memsql_strappend_free(retval, sql_condition_stringify(table->d.join.cond));
         }
      break;

   case SQL_nestedselect:
      retval = memsql_strappend_free(memsql_strdup("("), sql_select_stringify(table->d.select));
      retval = memsql_strappend_free(retval, memsql_strdup(")"));
      break;

   default:
      fprintf(stderr, "Invalid table type: %d\n", table->type);
      retval = NULL;
      }

   return retval;
   }

static char *
sql_logic_op_stringify(sql_logic_operator op)
   {
   switch (op)
      {
   case SQL_and:
      return memsql_strdup("and");
   case SQL_or:
      return memsql_strdup("or");
   default:
      fprintf(stderr, "invalid logic op: %d", op);
      }
   return NULL;
   }

static char *
sql_where_stringify(sql_where * where)
   {
   char *retval = NULL;

   if (!where)
      return NULL;

   switch (where->type)
      {
   case SQL_single:
      retval = sql_condition_stringify(where->d.single);
      break;

   case SQL_negated:
      retval = memsql_strappend_free(memsql_strdup("not "), sql_where_stringify(where->d.negated));
      break;

   case SQL_pair:
      retval = memsql_strappend_free(sql_where_stringify(where->d.pair.left), memsql_strdup(" "));
      retval = memsql_strappend_free(retval, sql_logic_op_stringify(where->d.pair.op));
      retval = memsql_strappend_free(retval, memsql_strdup(" "));
      retval = memsql_strappend_free(retval, sql_where_stringify(where->d.pair.right));
      }

   retval = memsql_strappend_free(memsql_strdup("("), retval);
   retval = memsql_strappend_free(retval, memsql_strdup(")"));

   return retval;
   }

static char *
sql_insert_stringify(sql_insert_statement * insert)
   {
   char *result;
   GList *walk;

   result = memsql_strdup("insert into ");
   result = memsql_strappend_free(result, sql_table_stringify(insert->table));

	if (insert->fields)
		{
		result = memsql_strappend_free (result, memsql_strdup (" ("));
		for (walk = insert->fields; walk != NULL; walk = walk->next)
			{
			result = memsql_strappend_free (result, sql_field_stringify (walk->data));
			if (walk->next)
				result = memsql_strappend_free(result, memsql_strdup(", "));
			}
		result = memsql_strappend_free (result, memsql_strdup (")"));			
		}

   result = memsql_strappend_free(result, memsql_strdup(" ("));

   for (walk = insert->values; walk != NULL; walk = walk->next)
      {
      result = memsql_strappend_free(result, sql_field_stringify(walk->data));
      if (walk->next)
         result = memsql_strappend_free(result, memsql_strdup(", "));
      }

   result = memsql_strappend_free(result, memsql_strdup(")"));

   return result;
   }

static char *
sql_select_stringify(sql_select_statement * select)
   {
   char *result;
   char *fields;
   char *tables;
   char *where;
   char *order;
   char *group;
   char *temp;
   GList *walk;

   result = memsql_strdup("select ");

   if (select->distinct)
      result = memsql_strappend_free(result, memsql_strdup("distinct "));

   fields = NULL;
   for (walk = select->fields; walk != NULL; walk = walk->next)
      {
      temp = sql_field_stringify(walk->data);
      fields = memsql_strappend_free(fields, temp);

      if (walk->next)
         fields = memsql_strappend_free(fields, memsql_strdup(", "));

      }

   result = memsql_strappend_free(result, fields);
   result = memsql_strappend_free(result, memsql_strdup(" from "));

   tables = NULL;
   for (walk = select->from; walk != NULL; walk = walk->next)
      {
      temp = sql_table_stringify(walk->data);
      tables = memsql_strappend_free(tables, temp);
      if (walk->next)
         tables = memsql_strappend_free(tables, memsql_strdup(", "));
      }

   result = memsql_strappend_free(result, tables);

   if (select->where)
      where = memsql_strappend_free(memsql_strdup(" where "), sql_where_stringify(select->where));
   else
      where = NULL;

   result = memsql_strappend_free(result, where);

   if (select->order)
      {
      order = memsql_strdup(" order by ");

      for (walk = select->order; walk != NULL; walk = walk->next)
         {
         order = memsql_strappend_free(order, sql_field_stringify(walk->data));
         if (walk->next)
            order = memsql_strappend_free(order, memsql_strdup(", "));
         }
      }
   else
      order = NULL;
   result = memsql_strappend_free(result, order);

   if (select->group)
      {
      group = memsql_strdup(" group by ");

      for (walk = select->group; walk != NULL; walk = walk->next)
         {
         group = memsql_strappend_free(group, sql_field_stringify(walk->data));
         if (walk->next)
            group = memsql_strappend_free(group, memsql_strdup(", "));
         }
      }
   else
      group = NULL;

   result = memsql_strappend_free(result, group);

   return result;
   }

static char *
sql_update_stringify (sql_update_statement *update)
{
	char *result;
	GList *walk;

	result = memsql_strappend_free (memsql_strdup ("update "), sql_table_stringify (update->table));
	result = memsql_strappend_free (result, memsql_strdup (" set "));
	
	for (walk = update->set; walk != NULL; walk = walk->next)
		{
		result = memsql_strappend_free (result, sql_condition_stringify (walk->data));
		if (walk->next)
			result = memsql_strappend_free (result, memsql_strdup (", "));
		}

	if (update->where)
		{
		result = memsql_strappend_free (result, memsql_strdup (" where "));
		result = memsql_strappend_free (result, sql_where_stringify (update->where));
		}

	return result;
}

/**
 * sql_stringify:
 * 
 * Covert a sql_statement into a string.  This is very useful for building
 * up sql queries.
 * 
 * Returns: The SQL statement or a %NULL.  Free after use.
 */

char *
sql_stringify(sql_statement * statement)
   {
   char *result = NULL;
   char *final;

   if (!statement)
      return NULL;

   switch (statement->type)
      {
   case SQL_select:
      result = sql_select_stringify(statement->statement);
      break;

   case SQL_insert:
      result = sql_insert_stringify(statement->statement);
      break;

	case SQL_update:
		result = sql_update_stringify (statement->statement);
		break;

   default:
      fprintf(stderr, "Invalid statement type: %d\n", statement->type);
      }

   if (result)
      final = strdup(result);
   else
      final = NULL;

   memsql_free(result);

   return final;
   }

static int
sql_statement_select_append_field(sql_select_statement * select, sql_field * field)
   {
   select->fields = g_list_append(select->fields, field);
   return 0;
   }

/**
 * sql_statement_append_field:
 * @statment: A Sql statement generated from parsing an sql statement
 * @table: Name of table to add, this can be %NULL
 * @fieldname: Field to add to the statment
 *
 * Adds an field into a select statement
 * 
 * Returns: non-zero on error.
 */
int
sql_statement_append_field(sql_statement * statement, char *table, char *fieldname)
   {
   sql_field_item *item;
   sql_field *field;
   GList *name = NULL;

   if (!fieldname)
      return -1;

   if (table)
      name = g_list_append(name, memsql_strdup(table));

   name = g_list_append(name, memsql_strdup(fieldname));
   item = sql_field_item_build(name);
   field = sql_field_build(item);

   switch (statement->type)
      {
   case SQL_select:
      sql_statement_select_append_field(statement->statement, field);
      break;

   case SQL_insert:
#warning "insert not handled - causes leak of field, item & name"

      break;

   default:
      fprintf(stderr, "Invalid statement type: %d", statement->type);
      }

   return 0;
   }

GList *
sql_statement_get_fields(sql_statement * statement)
   {
   GList *retval = NULL;
   GList *walk;
   char *temp1, *temp2;
   sql_select_statement *select;

   if (!statement)
      return NULL;

   if (!statement->type == SQL_select)
      return NULL;

   select = statement->statement;

   for (walk = select->fields; walk != NULL; walk = walk->next)
      {
      temp1 = sql_field_stringify(walk->data);
      temp2 = strdup(temp1);
      memsql_free(temp1);

      retval = g_list_append(retval, temp2);
      }
   return retval;
   }

GList *
sql_statement_get_tables(sql_statement * statement)
   {
   GList *retval = NULL;
   GList *walk;
   char *temp1, *temp2;
   sql_select_statement *select;

   if (!statement)
      return NULL;

   if (!statement->type == SQL_select)
      return NULL;

   select = statement->statement;

   for (walk = select->from; walk != NULL; walk = walk->next)
      {
      temp1 = sql_table_stringify(walk->data);
      temp2 = strdup(temp1);
      memsql_free(temp1);

      retval = g_list_append(retval, temp2);
      }

   return retval;
   }

char *
sql_statement_get_first_table(sql_statement * statement)
   {
   sql_select_statement *select;
   char *retval, *temp;

   if (!statement)
      return NULL;

   if (!statement->type == SQL_select)
      return NULL;

   select = statement->statement;

   temp = sql_table_stringify(select->from->data);
   retval = strdup(temp);
   memsql_free(temp);

   return retval;
   }