C++ database_error函数代码示例

  transaction::~transaction() noexcept(false)
  {
    if (db_) {
      auto rc = db_->execute(fcommit_ ? "COMMIT" : "ROLLBACK");
      if (rc != SQLITE_OK)
	throw database_error(*db_);
    }
  }

 database::database(char const* dbname, int flags, char const* vfs) : db_(nullptr)
 {
   if (dbname) {
     auto rc = connect(dbname, flags, vfs);
     if (rc != SQLITE_OK)
       throw database_error("can't connect database");
   }
 }

postgresql_statement::postgresql_statement(shared_ptr<postgresql_connection_impl> conn,
					   const string &query)
  : conn(conn)
{
  postgresql_result res(PQprepare(conn->get(), "", convert_query(query).c_str(), 0, NULL));

  if (!res.command_ok())
    throw database_error(PQresultErrorMessage(res.get()));
}

	sqlite3_connection::sqlite3_connection( sqlite3 * dbh )
		: m_db(0), m_name()
	{
		if( ! dbh )
		{
			throw database_error( "sqlite3_connection(sqlite3*) ctor was passed a null db handle." );
		}
		this->take( dbh );
	}

	void sqlite3_command::finalize()
	{
		if( this->stmt )
		{
			if(sqlite3_finalize(this->stmt)!=SQLITE_OK)
				throw database_error(this->con);
			this->stmt = 0;
		}
	}

void postgresql_connection_impl::reconnect()
{
  if (PQstatus(conn)==CONNECTION_OK)
    return;

  PQreset(conn);

  if (PQstatus(conn)!=CONNECTION_OK)
    throw database_error("fail to reconnect");
}

void update_db(const char *sql) {
	sqlite3 *db;
	int ret;
	char *errmsg;

	db = get_db();
	ret = sqlite3_exec(db, sql, NULL, NULL, &errmsg);
	if (ret != SQLITE_OK) {
		database_error(errmsg, sql);
	}
}

	table_generator::table_generator( sqlite3_connection & con, std::string const & n )
		: m_pimpl( new table_generator::table_generator_impl )
	{
		int check = con.executeint( "select count(*) from sqlite_master where type like 'table' and name like '"+n+"'" );
		// ^^^ we use 'like' here because sqlite3 is case-insensitive
		if( 0 != check )
		{
			throw database_error( "table_generator() db table '%s' already exists.", n.c_str() );
		}
		this->m_pimpl->db = &con;
		this->m_pimpl->name = n;
	}

	void sqlite3_command::prepare( char const * sql, int len )
	{
		if( this->stmt ) this->finalize();
		const char *tail=NULL;
		int rc = sqlite3_prepare( this->con.db(), sql, len, &(this->stmt), &tail );
		if( SQLITE_OK != rc )
		{
			throw database_error("sqlite3_command::prepare([%s]) failed. Reason=[%s]",
					     sql, sqlite3_errmsg( this->con.db() ) );
		}
		this->argc=sqlite3_column_count(this->stmt);
	}

/* Return False on error, True on success */
int load_add_class(char *class_name, int class_id, int superclass_id, char *superclass_name)
{
   /* Build up a class data structure for the new class. */
   id_type id = (id_type)SafeMalloc(sizeof(id_struct));
   id_type temp_id = (id_type)SafeMalloc(sizeof(id_struct));
   class_type c = (class_type)SafeMalloc(sizeof(class_struct));

   // Adding new built-in object types will render existing kodbase.txt files
   // incompatible. This isn't a problem as a pre-existing kodbase.txt is only
   // required for reloading a live server, so a new one can be made. Check
   // for built-in class name/ID mismatches here and instruct the user to
   // delete kodbase.txt if this check fails.

   extern id_struct BuiltinIds[];
   if ((strcmp(BuiltinIds[SETTINGS_CLASS].name, class_name) == 0
         && class_id != SETTINGS_CLASS)
      || (strcmp(BuiltinIds[REALTIME_CLASS].name, class_name) == 0
         && class_id != REALTIME_CLASS)
      || (strcmp(BuiltinIds[EVENTENGINE_CLASS].name, class_name) == 0
         && class_id != EVENTENGINE_CLASS))
   {
      database_error("Incompatible kodbase.txt. Delete the file and recompile.");
      return False;
   }

   id->name = strdup(class_name);
   id->idnum = class_id;
   id->type = I_CLASS;
   id->source = DBASE;

   c->class_id = id;
   c->properties = c->messages = c->resources = c->classvars = NULL;
   c->is_new = False;  /* Don't generate code for this class */
   /* Store superclass id # in pointer for now.  Id # will be converted to pointer
    * when build_superclasses below is called. */
   c->superclass = (class_type) superclass_id;

   /* Add to list of classes that have been read in */
   st.classes = list_add_item(st.classes, (void *) c);

   current_class = c;
   st.curclass = class_id;
   current_message = NULL;

   /* Call table_insert instead of add_identifier so that our id # from
    * the database file is preserved. 
    */
   if (table_insert(st.globalvars, (void *) id, id_hash, id_compare) == 0)
      return True;
   else return False;
}

	void sqlite3_connection::open(const wchar_t *db) {
		if(sqlite3_open16(db, &this->m_db)!=SQLITE_OK)
			throw database_error("unable to open database");
		try
		{
			this->on_open();
		}
		catch(...)
		{
			try { this->close(); }
			catch(...) { /* ignore */ }
			throw;
		}
	}

void Database::open(std::string fname)
{
	sqlite3* db=NULL;

	try{
		//TODO UTF-8 string
		int rc=sqlite3_open(fname.c_str(), &db);
		if(rc!=SQLITE_OK)
			throw database_error( std::string("database error: ")+sqlite3_errmsg(db) );
		con=shared_connection(new autoclosed_con(db));

	}catch(std::runtime_error e){
		if(db)
			sqlite3_close(db);
		throw e;
	}
}

void
router::set_nodes_total(const size_t total, vm::all *all)
{
   nodes_per_remote = total / world_size;
   
#ifndef USE_SIM
   if(nodes_per_remote == 0)
      throw database_error("Number of nodes is less than the number of remote machines");
#endif

   all->NUM_NODES_PER_PROCESS = nodes_per_remote;
   
   // cache values for each remote
   
   for(remote::remote_id i(0); i != (remote::remote_id)world_size; ++i)
      remote_list[i]->cache_values(world_size, nodes_per_remote, total);
}

/*
* 从DATA_IN中读取用户的输入，比如scanf 需要的输入就从这里得到
*/
void get_data_input(char *code_id) {
	char sql[SQL_LEN] = {0};
	char *errmsg;
	int ret;
	sqlite3 *db;

	FILE *fp = fopen(DATA_IN, "w");
	if (fp == NULL) {
		write_log(INT_RE, 1, "fopen error(in get_data_input)");
		exit(-1);
	}

	sprintf(sql, "select data_input from code where code_id='%s'", code_id);
	db = get_db();
	ret = sqlite3_exec(db, (const char*)sql, get_data_input_cb,\
		(void*)fp, &errmsg);
	fclose(fp);
	if (ret != SQLITE_OK) {
		database_error(errmsg, sql);
	}
}

int load_add_resource(char *resource_name, int resource_id)
{
   id_type id = (id_type) SafeMalloc(sizeof(id_struct));
   resource_type r = (resource_type) SafeMalloc(sizeof(resource_struct));
   
   id->name = strdup(resource_name);
   id->idnum = resource_id;
   id->type = I_RESOURCE;
   id->ownernum = st.curclass;
   id->source = DBASE;

   r->lhs = id;
   r->rhs = NULL;

   /* Add resource to resource list of current class */
   if (current_class == NULL)
      database_error("Resource appears outside of class in database file");
   current_class->resources = list_add_item(current_class->resources, (void *) r);

   /* OK if parameter already in table; just ignore return value */
   table_insert(st.globalvars, (void *) id, id_hash, id_compare);
   return True;
}