Excel-Datenbank und VBA-Grundlagen

[johndoe953557]

gut dann werd ich das erstmal ausprobieren,
und dann wenn ich sehe das das zu umständlich wird,
access oder ähnliches empfehlen=)

[johndoe953557]

so so so =/

das mit excel ist echt murks,
hab ich jetz mal so festgestellt =/

naja gibts denn neben access auch freeware in sachen Datenbank tools???
sollten aber schon benutzerfreundlich sein

[Scorcher24_]

Open Office enthält auch eine Datenbank Lösung.
http://de.openoffice.org/product/base.html

[johndoe953557]

Open Office enthält auch eine Datenbank Lösung.
http://de.openoffice.org/product/base.html

bin grad noch über MySQL gestolpert,
hat damit einer erfahrung???

[Scorcher24_]

MySQL ist eine Server-Lösung. Nicht gerade für lokale Datenbanken geeignet. Das nimmt man für Webseiten wie diese hier.

[JesusOfCool]

SQLite ist ne offline datenbank, also sowas was du suchst. ich weiß aber nicht wie gute verwaltungsprogramme und so es dafür gibt. wäre vmtl eher was.

[Scorcher24_]

SQLite ist eher was für Programmierer um die API in das eigene Programm einzubinden für lokale Datenbanken. Bin lustigerweise grade dabei das in meine GameEngine einzubinden als ScriptSpeicher und auch für Speicherstände etc.
Es gibt schon einige wenige Programme dafür, aber was spricht gegen Base von Open Office? Das ist doch genau was er sucht.. Access kostenlos (naja, fast). Ansonsten wüsste ich mal gerne die Anforderungen an die Datenbank, wenn hier sogar mit MySQL geschossen wird.

[JesusOfCool]

letztenendes ist eh egal, coden muss man so oder so, und wenn man davon 0 ahnung hat wirds schon nicht mehr so einfach.

funktioniert SQLite gut? ist es umständlich zu verwenden oder relativ einfach?

[Scorcher24_]

Code: Alles auswählen

namespace NightLight{

int sqlite_callback (void* ptr,int argc ,char** argv, char** err)
{
	return 0;
}

NLSqlite::NLSqlite()
: m_db(NULL)
{}

NLSqlite::~NLSqlite()
{
	this->closeDatabase();
}


//////////////////////////////////////////////////////////////////////////
// Opens a database with no flags.
//////////////////////////////////////////////////////////////////////////
bool NLSqlite::openDatabase( const std::string& db )
{
	if ( sqlite3_open(db.c_str(), &m_db) == SQLITE_OK )
	{
		if ( m_db != NULL )
		{
			NLTrace("[NLSqlite] Database with name '" + db + std::string("' opened."));
			return true;
		}
	}
	NLError("[NLSqlite] Unable to open database with name '" + db + std::string("'. Message from SQLite3: '") + sqlite3_errmsg(m_db) + std::string("'."));
	sqlite3_close(m_db);
	return false;
}

//////////////////////////////////////////////////////////////////////////
// Opens the Database with the give SQLITE_FLAGS
//////////////////////////////////////////////////////////////////////////
bool NLSqlite::openDatabase( const std::string& db, int flags )
{
	if ( sqlite3_open_v2(db.c_str(), &m_db, flags, NULL) == SQLITE_OK )
	{
		if ( m_db != NULL )
		{
			NLTrace("[NLSqlite] Database '" + db + std::string("' opened (using flags)."));
			return true;
		}
	}
	NLError("[NLSqlite] Unable to open database '" + db + std::string("' (using flags). Message from SQLite3: '") + sqlite3_errmsg(m_db) + std::string("'."));
	sqlite3_close(m_db);
	m_db = NULL;
	return false; 
}

//////////////////////////////////////////////////////////////////////////
// Creates a Table
// SQL-Statement: CREATE TABLE %tabelname% ( %fieldname% %type%, %fieldname% %type, ..);
//////////////////////////////////////////////////////////////////////////
int NLSqlite::createTable( const std::string& name, const NLSQLTableDescriptor::TTableList& lst )
{
	if (m_db != NULL)
	{
		int result = 0;
		char* err = NULL;
		std::stringstream sql;
		sql << "create table " << name << " (";

		NLSQLTableDescriptor::TTableList::const_iterator it = lst.begin();
		for ( it; it != lst.end(); it++ )
		{
			if ( it != lst.begin() )
			{
				sql << ", ";
			}	

			const NLSQLTableDescriptor& field = *it;
			sql << field.getName() << " " << getFieldDescriptionByType(field.getType());				
		}		
		sql << ");";
		result = sqlite3_exec(m_db, sql.str().c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError("[NLSqlite] Unable to create table '" + name + std::string("'. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql.str());
		}	
		sqlite3_free(err);
		return result;
	}
	NLError("[NLSqlite] Cannot create a table with no database opened.");
	return -1;
}


//////////////////////////////////////////////////////////////////////////
// Returns the correct sql-strings for the given flags
//////////////////////////////////////////////////////////////////////////
std::string NLSqlite::getFieldDescriptionByType( long type )
{
	std::stringstream ss;
	
	// Search for normaly types
	if ( (type & NLTT_INTEGER) == NLTT_INTEGER )
	{
		ss << "integer";
	}
	else if ( (type & NLTT_BOOL) == NLTT_BOOL )
	{
		ss << "bool";
	}
	else if ( (type & NLTT_TEXT) == NLTT_TEXT )
	{
		ss << "text";
	}
	else if ( (type & NLTT_BLOB) == NLTT_BLOB )
	{
		ss << "blob";
	}

	// Now lookup "special" additions
	if ( (type & NLTT_UNIQUE) == NLTT_UNIQUE )
	{
		ss << " unique";
	}
	if ( (type & NLTT_PRIMARY) == NLTT_PRIMARY )
	{
		ss << " primary key";
	}
	if ( (type & NLTT_AUTOINCR) == NLTT_AUTOINCR )
	{
		ss << " autoincrement";
	}

	return ss.str();
}

//////////////////////////////////////////////////////////////////////////
// Deletes a table forever
//////////////////////////////////////////////////////////////////////////
int NLSqlite::deleteTable( const std::string& name )
{
	if ( m_db != NULL )
	{
		std::string sql = "DROP TABLE " + name;
		char* err = NULL;
		int result = sqlite3_exec(m_db, sql.c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError("[NLSqlite] Unable to delete table '" + name + std::string("'. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql);
		}	
		sqlite3_free(err);
		return result;
	}
	NLError("[NLSqlite] Cannot delete a table with no database opened.");
	return -1;
}

//////////////////////////////////////////////////////////////////////////
// Executes a raw SQL-Command
//////////////////////////////////////////////////////////////////////////
int NLSqlite::exec( const std::string& sql )
{
	if ( m_db != NULL )
	{
		char* err = NULL;
		int result = sqlite3_exec(m_db, sql.c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError(std::string("[NLSqlite] Unable to execute the sql-command. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql);
		}	
		sqlite3_free(err);
		return result;
	}
	NLError("[NLSqlite] Cannot execute an sql-command with no database opened.");
	return -1;
}


//////////////////////////////////////////////////////////////////////////
// Inserts all Descriptors into the Table
//////////////////////////////////////////////////////////////////////////
int NLSqlite::insertIntoTable( const std::string& name, const NLSQLTableDescriptor::TTableList& lst )
{
	if (m_db != NULL)
	{
		int result = 0;
		char* err = NULL;
		std::stringstream sql_names;
		std::stringstream sql_values;

		sql_names  << "INSERT INTO " << name << " (";
		sql_values << " VALUES( ";
		{
			NLSQLTableDescriptor::TTableList::const_iterator it = lst.begin();
			for ( it; it != lst.end(); it++ )
			{
				if ( it != lst.begin() )
				{
					sql_names << ", ";
					sql_values<< ", ";
				}	

				const NLSQLTableDescriptor& field = *it;
				sql_names  << field.getName();	
				sql_values << "'" << field.getValue() << "'";
			}	
			sql_names  << ") ";
			sql_values << ");";
		}

		std::stringstream sql;
		sql << sql_names.str() << sql_values.str();

		// Execute
		result = sqlite3_exec(m_db, sql.str().c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError("[NLSqlite] Unable to insert into table '" + name + std::string("'. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql.str());
		}	
		sqlite3_free(err);
		return result;
	}
	NLError("[NLSqlite] Cannot insert into a table with no database opened.");
	return -1;
}


//////////////////////////////////////////////////////////////////////////
// Replaces an existing entry in the Database
// SQL: UPDATE OR FAIL tabel1 SET Artist="Queen" WHERE artist="Justin Bieber"
//////////////////////////////////////////////////////////////////////////
int NLSqlite::replaceInTable( const std::string& name, const std::string& key, const std::string& key_old_value, const std::string& new_value )
{
	if (m_db != NULL)
	{
		int result = 0;
		char* err = NULL;

		std::stringstream sql;
		//
		sql << "UPDATE OR FAIL " << name << " SET " << key << " = '" << new_value << "' WHERE " << key << " = '" << key_old_value <<"';";

		// Execute
		result = sqlite3_exec(m_db, sql.str().c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError("[NLSqlite] Unable to replace into table '" + name + std::string("'. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql.str());
		}	
		sqlite3_free(err);
		return result;
	}
	NLError("[NLSqlite] Cannot replace into a table with no database opened.");
	return -1;
}


//////////////////////////////////////////////////////////////////////////
// Closes the Database for good
//////////////////////////////////////////////////////////////////////////
void NLSqlite::closeDatabase()
{
	if ( m_db != NULL )
	{
		sqlite3_close(m_db);
		m_db = NULL;
	}	
}

//////////////////////////////////////////////////////////////////////////
// Checks if a table exists
//////////////////////////////////////////////////////////////////////////
bool NLSqlite::tableExists( const std::string& name )
{
	if (m_db != NULL)
	{
		int result = 0;
		char* err = NULL;
		std::stringstream sql;
		sql << "SELECT COUNT(type) FROM sqlite_master WHERE type='table' AND name='" << name << "';";

		// Execute
		result = sqlite3_exec(m_db, sql.str().c_str(), sqlite_callback, this, &err);
		if ( result != SQLITE_OK )
		{
			NLError("[NLSqlite] Unable to check for table '" + name + std::string("'. Message from SQLite3: '") + err + std::string("'."));
			NLError("[NLSqlite] SQL-String was: " + sql.str());
			return false;
		}	
		sqlite3_free(err);
		return true;
	}
	NLError("[NLSqlite] Cannot check for a table with no database opened.");
	return false;
}



} // namespace

Relativ einfach zu verwenden, wie man am Code sieht. Allerdings hab ich diesen Ansatz fallen gelassen, da er zu umständlich wird. Ich mache grade einen neuen, kompletteren Ansatz mit precompiled SQL-Statements. Ist erstens schneller und 2tens besser zu verwenden als die SQL-Kommandos on the fly zu erzeugen wie hier.

Aber es ist schon Unterschied ob man sich ein paar Abfragen scripted oder mit C/C++ ein komplettes Programm hinklatscht.
Und solange er mir nicht sagt was genau er will, kann ich ihm da auch nicht weiterhelfen^^.

[JesusOfCool]

ist wirklich relativ simpel. in der arbeit hatte ich ne zeit lang mit oledb für mssql, oracle und db2 zu tun, dagegen ist das hier regelrecht kindergarten ^^, auch wenns boa-pinta vielleicht etwas abschrecken mag.

[Scorcher24_]

Naja, sqlite ist ja genau dafür designed. Schnell zu verwendende Datenbank für Programmierer die eben keine Server-Client-Anwendung schreiben, sondern nur einen Undo/Redo Stack brauchen oder einfach nur Daten speichern wollen.
Hatte auch mal embedded MySQL ausprobiert, aber das ist komplex und damit auch fehleranfällig.

[johndoe953557]

oh man da kommt ne menge Arbeit auf mich zu, so oder so

naja also es sieht so aus,
es handelt sich um einen Prozess in der Firma,
den habe ich nun mit Hilfe von Excel aufgearbeitet,
dabei entstanden sowohl Tabellen als auch schematische Darstellungen,

diese gilt es nun zu verwalten, weil es doch schon etwas komplex geworden ist und es mühselig ist sich da immer durch zu klicken.
Beispiel:
Ein Prozess hat Schnittstellen zu anderen Prozessen, weiterhin gliedert sich der Prozess auch noch in verschiedene Tätigkeit (2 Klassen) die einen gewissen Input sowie Output haben, diesen In/outputs sollen dann noch Arbeitsprodukte wie zum Beispiel Protokolle etc. zugeordnet werden können.

nun gibt es aber net nur 2 Prozesse sondern so um die 15, mit über 100 Tätigkeiten und über 100 Arbeitsprodukten etc.

diesen sollen also über Filter und such Funktionen darstellbar und schnell aufrufbar sein

so ich denke jetzt hat man ne grobe Zusammenfassung von dem was ich "will"

[Scorcher24_]

Naja, Base sollte da eigentlich am geeignetsten sein.
Abfragen und Formulare helfen da durchaus. Ignoriere SQLite, das ist wie gesagt eher für Programmierer. Ausser du möchtest eine komplexe Anwendung dafür entwickeln. Wovon ich aber abrate nach Möglichkeit.
Simplicity is Productivity.

[JesusOfCool]

bin da ganz scorchers meinung. du brauchst ja doch nur 0815 zeug und das geht damit sicher auch gut genug.

[johndoe953557]

gut gut,
dann werd ich mich mal dran machen=)

großes dankeschön für euer interesse und hilfe bei der lösungsfindung
habt mir echt geholfen