JK-Wiki edv:prg:esql_c:example

edv:prg:esql_c:example:behandlung_von_blobs

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:26+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Behandlung von BLOBs ======
	+
	+	Einige nützliche Referenzen zu IBM Informix ESQL/C Programmer's Manual:
	+
	+	BLOB (in den Speicher) lesen:
	+
	+	[[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc139.htm]]
	+
	+	Buffer-Inhalt in einem BLOB abspeichern:
	+
	+	[[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc139.htm]]
	+
	+	BLOB in ein File ausgeben bzw. aus einem File update'n:
	+
	+	[[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc144.htm]]
	+
	+	[[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc145.htm]]
	+
	+	Ein weiteres Beispiel:
	+
	+	[[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc341.htm]]
	+
	+	----
	+	Stand: 24.11.2010
	+
	+	EOF
	+

edv:prg:esql_c:example:db_exec_sql

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:26+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== db_exec_sql ======

	+	Modul mit einigen (Informix-)DB-Funktionen
	+
	+	db_exec_sql.h:
	+
	+	<code c>
	+	/*********************************************************************
	+	*
	+	* Autor: Jürgen Kreick
	+	* Version: 1.0.0 vom 24.11.2010
	+	*
	+	**********************************************************************
	+	*
	+	* Hinweise zum Modul/Quelltext:
	+	*
	+	* In der aktuellen Version werden nur Verbindungen zu einer einzigen
	+	* DB pro Sitzung unterstützt.
	+	* Unterstützung von parallelen Sitzungen (zeitgleiche mehrere DB-Verbindungen zu
	+	* jeweils unterschiedlichen DB) sind momentan nicht geplant.
	+	*
	+	**********************************************************************
	+	*
	+	* Release Notes:
	+	*
	+	* Ver 1.0.0 (vom 24.11.2010):
	+	* Die erste Version des Moduls. Umfasst (nach aussen) folgende Funktionen:
	+	* dbInit(), dbDone(), dbSetIsolation(), dbSetModeWait().
	+	*
	+	**********************************************************************/
	+
	+	#ifndef db_exec_sql_h_H
	+	#define db_exec_sql_h_H
	+
	+	// Rückgabewerte:
	+	#define RC_DB_OK 0
	+	#define RC_DB_ERR -1
	+	#define RC_DB_NOTFOUND 100
	+
	+	// IsolationsLevel
	+	#define DIRTY_READ 1
	+	// "Dirty Read" und "Uncommitted Read" ist das gleiche
	+	#define UNCOMMITTED_READ 1
	+	#define COMMITTED_READ 2
	+	// Die Liste ist nicht vollständig!
	+
	+	// Werte für dbEndTransaction()
	+	#define TRANSACTION_COMMIT 1
	+	#define TRANSACTION_ROLLBACK 2
	+	// Transaktionskontext: ON = erforderlich, OFF = nicht erforderlich
	+	#define TRANSACTION_OFF 0
	+	#define TRANSACTION_ON 1
	+	// Transaktion: IN_OF_TRNS = man befindet sich innerhalb eines Transaktionskontextes, OUT_OF_TRNS = außerhalb
	+	#define TRANSACTION_IN_OF_TRNS 1
	+	#define TRANSACTION_OUT_OF_TRNS 0
	+
	+	// Log-Meldungen
	+	#define LOG_FEHLGESCHLAGEN "fehlgeschlagen."
	+	#define LOG_BEGIN_WORK "BEGIN WORK"
	+	#define LOG_BEGIN_WORK_FEHLGESCHLAGEN "BEGIN WORK fehlgeschlagen."
	+	#define LOG_COMMIT_WORK "COMMIT WORK"
	+	#define LOG_COMMIT_WORK_FEHLGESCHLAGEN "COMMIT WORK fehlgeschlagen."
	+	#define LOG_ROLLBACK_WORK "ROLLBACK WORK"
	+	#define LOG_ROLLBACK_WORK_FEHLGESCHLAGEN "ROLLBACK WORK fehlgeschlagen."
	+	#define LOG_TRANSACTION_PARAM_ERROR "Falsche Parameter beim Aufruf von dbEndTransaction()"
	+
	+
	+	// ****************** Prototypen **************************************
	+
	+	// dbInit() wird ein Mal pro DB-Sitzung aufgerufen und baut eine Verbindung zur
	+	// DB auf.
	+	//
	+	// Parameter:
	+	//
	+	// char *dbName : Name der DB (z.B. "test_db@test_system")
	+	// int extLogFileID : externe LogFileID für das Logging-System
	+	//
	+	// Rückgabewert: RC_DB_OK (Erfolg) oder RC_DB_ERR (bei Fehlern)
	+	int dbInit (const char *dbName, int extLogFileID);
	+
	+	// dbDone() wird ein Mal pro DB-Sitzung aufgerufen und baut die existierende
	+	// Verbindung zur DB ab.
	+	//
	+	// Parameter: keine.
	+	//
	+	// Rückgabewert: RC_DB_OK (Erfolg) oder RC_DB_ERR (bei Fehlern)
	+	int dbDone ();
	+
	+	// dbSetIsolation() setzt den aktuellen IsolationsLevel für die Verbindung
	+	int dbSetIsolation (int level);
	+
	+	// dbSetModeWait() setzt die Wartezeit in Sekunden beim Warten auf einen gelockten Satz.
	+	// Negative Werte für "sec" bedeuten kein Warten.
	+	// sec = 0 bedeutet keine Begrenzung beim Warten.
	+	int dbSetModeWait (int sec);
	+
	+	// Diese Funktion führt einfache SQLs aus.
	+	// Eingabeparameter:
	+	// sql - SQL-String, der ausgeführt werden soll;
	+	// text - Text (z.B. updated / deleted / inserted) für Massenoperationen
	+	// funktionname - "__func__"-Makro der aufrufenden Funktion (für Trace)
	+	// Ausgabeparameter:
	+	// rows - Falls NULL, wird ignoriert, sonst wird dort bei Erfolg die Zahl durch SQL betroffener Sätze zurück gegeben
	+	int execSimpleSQL (const char sql, const int rows, const char text, const char modulName, int lineNumber, const char *functName);
	+
	+	// Transaktionkontext öffnen (BEGIN WORK;)
	+	int dbBeginTransaction ();
	+	// Transaktion beenden (mit COMMIT WORK; oder ROLLBACK WORK;)
	+	int dbEndTransaction (int transactionEnd);
	+
	+
	+	/* Everything else goes here */
	+
	+	#endif
	+	</code>
	+
	+	db_exec_sql.ec:
	+
	+	<code c>
	+	#include "db_exec_sql.h"
	+	// Wehen Logging:
	+	#include "logging_ext.h"
	+
	+
	+	// Konstanten:
	+	#define TMP_STR_LEN_MAX 8191
	+
	+	#define ON 1
	+	#define OFF 0
	+
	+
	+	// ****************** lokale Strukturen **************************************
	+
	+
	+	// ****************** externe Variablen **************************************
	+
	+	int dbLogFileID = 0;
	+
	+
	+	// ****************** lokale Variablen **************************************
	+
	+	int dbConnected = 0; // 0 - keine Verbindung, 1 - Verbindung existiert (oder OFF/ON)
	+
	+	// ****************** interne Funktionen **************************************
	+
	+
	+	// ****************** export-Funktionen **************************************
	+
	+	int dbInit (const char *dbName, int extLogFileID)
	+	{
	+	int rc = RC_OK;
	+	int rc_SQL = RC_DB_OK;
	+	char logStr [TMP_STR_LEN_MAX + 1];
	+
	+	EXEC SQL BEGIN DECLARE SECTION;
	+	char dbDatabase [TMP_STR_LEN_MAX + 1];
	+	EXEC SQL END DECLARE SECTION;
	+
	+	dbLogFileID = extLogFileID; // Da es von außen gesetzt wird, übernehmen wir es blind (sicherheitstechnisch unkritisch).
	+
	+	memset(logStr, '\0', sizeof(logStr));
	+	memset(dbDatabase, '\0', sizeof(dbDatabase));
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	// Plausibilitätsprüfung:
	+	if (dbName) // dbName existiert?
	+	{
	+	strlcpy(dbDatabase, dbName, sizeof(dbDatabase)); // Vor dem trim'men umkopieren
	+	trimAll(dbDatabase, NULL, sizeof(dbDatabase)); // Von den Leerzeichen links und rechts befreien
	+	if (strlen(dbDatabase) <= 0) // Der DB-Name darf nicht leer sein
	+	{
	+	logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "Fehlerhafter Aufruf: Name der DB ist leer.");
	+	rc = RC_ERR;
	+	} // if
	+	}
	+	else // dbName darf nicht NULL sein
	+	{
	+	logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "Fehlerhafter Aufruf: Parameter 'dbName' ist NULL.");
	+	rc = RC_ERR;
	+	} // if
	+
	+
	+	if (!rc)
	+	{
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "Es wird versucht eine Verbindung zur DB aufzubauen...");
	+	if (dbConnected) // Verbindung ist bereits vorhanden
	+	{
	+	logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "Eine Verbindung zur DB existiert bereits.");
	+	rc = RC_ERR;
	+	} // if
	+	} // if
	+
	+	if (!rc)
	+	{
	+	snprintf(logStr, sizeof(logStr), "Database = [%s]", dbDatabase);
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, logStr);
	+
	+	EXEC SQL DATABASE :dbDatabase ;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	} // if
	+
	+	if (!rc) logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "Verbindung zur DB erfolgreich aufgebaut.");
	+	else logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "Verbindung zur DB konnte nicht aufgebaut werden.");
	+
	+	if (!rc) dbConnected = ON;
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc);
	+	return rc;
	+	} // dbInit()
	+
	+
	+	int dbDone ()
	+	{
	+	int rc = RC_OK;
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	if (dbConnected) // Verbindung existiert
	+	{
	+	// TODO: z.B. Cursor frei geben
	+	} // if
	+
	+	if (dbConnected) dbConnected = OFF;
	+	else rc = RC_ERR; // Es gibt keine Verbindung, die abgebaut werden soll.
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc);
	+	return rc;
	+	} // dbDone()
	+
	+
	+	int dbSetIsolation (int level)
	+	{
	+	int rc = RC_OK;
	+	int rc_SQL = RC_DB_OK;
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	switch (level)
	+	{
	+	case DIRTY_READ:
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "SET ISOLATION TO DIRTY READ;");
	+	EXEC SQL SET ISOLATION TO DIRTY READ;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	break; // case DIRTY_READ
	+
	+	case COMMITTED_READ:
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "SET ISOLATION TO COMMITTED READ;");
	+	EXEC SQL SET ISOLATION TO COMMITTED READ;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	break; // case COMMITTED_READ
	+
	+	default: rc = RC_ERR;
	+	} // switch (level)
	+
	+	if (rc) logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "IsolationsLevel konnte nicht gesetzt werden.");
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc);
	+	return rc;
	+	} // int dbSetIsolation()
	+
	+
	+	int dbSetModeWait (int sec)
	+	{
	+	int rc = RC_OK;
	+	int rc_SQL = RC_DB_OK;
	+
	+	EXEC SQL BEGIN DECLARE SECTION;
	+	char tmpStrSQL [TMP_STR_LEN_MAX + 1];
	+	EXEC SQL END DECLARE SECTION;
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	memset(tmpStrSQL, '\0', sizeof(tmpStrSQL));
	+
	+	if (sec < 0) // Kein Warten.
	+	{
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "SET LOCK MODE TO NOT WAIT;");
	+	EXEC SQL SET LOCK MODE TO NOT WAIT;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	}
	+	else if (sec == 0) // Keine Begrenzung beim Warten.
	+	{
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, "SET LOCK MODE TO WAIT;");
	+	EXEC SQL SET LOCK MODE TO WAIT;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	}
	+	else // "sec" Sekunden Warten.
	+	{
	+	snprintf(tmpStrSQL, sizeof(tmpStrSQL), "SET LOCK MODE TO WAIT %i;", sec);
	+	logLog(LOG_NOTICE, dbLogFileID, __FILE__, __LINE__, __func__, tmpStrSQL);
	+	EXEC SQL EXECUTE IMMEDIATE :tmpStrSQL;
	+	if (rc_SQL = sqlca.sqlcode) rc = RC_ERR;
	+	} // if
	+
	+	if (rc) logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, "WaitMode konnte nicht gesetzt werden.");
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc);
	+	return rc;
	+	} // int dbSetModeWait()
	+
	+
	+	int execSimpleSQL (const char sql, const int rows, const char text, const char modulName, int lineNumber, const char *functName) // Führt einfache SQLs aus
	+	{
	+	int rc_SQL = RC_DB_OK;
	+	int countRows = 0;
	+	char tmpStr [TMP_STR_LEN_MAX + 1];
	+
	+	EXEC SQL BEGIN DECLARE SECTION;
	+	char tmpStrSQL [TMP_STR_LEN_MAX + 1];
	+	EXEC SQL END DECLARE SECTION;
	+
	+	countRows = 0;
	+	memset(tmpStr, '\0', sizeof(tmpStr));
	+	memset(tmpStrSQL, '\0', sizeof(tmpStrSQL));
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	logLog(LOG_DEBUG, dbLogFileID, __FILE__, __LINE__, __func__, sql);
	+	strlcpy(tmpStrSQL, sql, sizeof(tmpStrSQL));
	+	logLog(LOG_INFO, dbLogFileID, __FILE__, __LINE__, __func__, tmpStrSQL);
	+
	+	EXEC SQL EXECUTE IMMEDIATE :tmpStrSQL;
	+	if (rc_SQL = sqlca.sqlcode)
	+	{
	+	logLogRC_SQL(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, LOG_FEHLGESCHLAGEN, tmpStrSQL, rc_SQL);
	+	snprintf(tmpStr, sizeof(tmpStr), "Aufgerufen aus %s[%d]:%s()", modulName, lineNumber, functName);
	+	logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, tmpStr);
	+	}
	+	else
	+	{
	+	countRows = sqlca.sqlerrd[2]; // Anzahl betroffener Saetze uebernehmen
	+	if (text) // Falls nicht NULL
	+	{
	+	snprintf(tmpStr, sizeof(tmpStr), "%d rows %s.", countRows, text);
	+	logLog(LOG_INFO, dbLogFileID, __FILE__, __LINE__, __func__, tmpStr);
	+	} // if
	+	if (rows) // Falls nicht NULL
	+	{
	+	// Anzahl betroffener Saetze zurueck geben
	+	rows = countRows; // Achtung! Es wird nicht ueberprueft, ob "rows" ausreichend Platz hat!
	+	} // if
	+	} // if
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc_SQL);
	+	return rc_SQL;
	+	} // execSimpleSQL()
	+
	+
	+	int dbBeginTransaction () // Transaktionkontext öffnen
	+	{
	+	int rc_SQL = RC_DB_OK;
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	logLog(LOG_INFO, dbLogFileID, __FILE__, __LINE__, __func__, LOG_BEGIN_WORK);
	+	EXEC SQL BEGIN WORK;
	+	if (rc_SQL = sqlca.sqlcode) logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, LOG_BEGIN_WORK_FEHLGESCHLAGEN);
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc_SQL);
	+	return rc_SQL;
	+	} // dbBeginTransaction()
	+
	+
	+
	+	int dbEndTransaction (int transactionEnd) // Transaktion beenden (mit COMMIT WORK; oder ROLLBACK WORK;)
	+	{
	+	int rc_SQL = RC_DB_OK;
	+
	+	logEntry(LOG_INFO, dbLogFileID, __FILE__, __func__);
	+
	+	switch (transactionEnd) // Entweder COMMIT WORK; oder ROLLBACK WORK;
	+	{
	+	case TRANSACTION_COMMIT: // COMMIT WORK;
	+	logLog(LOG_INFO, dbLogFileID, __FILE__, __LINE__, __func__, LOG_COMMIT_WORK);
	+	EXEC SQL COMMIT WORK;
	+	if (rc_SQL = sqlca.sqlcode) logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, LOG_COMMIT_WORK_FEHLGESCHLAGEN);
	+	break; // case TRANSACTION_COMMIT:
	+
	+	case TRANSACTION_ROLLBACK: // ROLLBACK WORK;
	+	logLog(LOG_INFO, dbLogFileID, __FILE__, __LINE__, __func__, LOG_ROLLBACK_WORK);
	+	EXEC SQL ROLLBACK WORK;
	+	if (rc_SQL = sqlca.sqlcode) logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, LOG_ROLLBACK_WORK_FEHLGESCHLAGEN);
	+	break; // case TRANSACTION_ROLLBACK:
	+
	+	default: // Unzulässiger Parameterwert
	+	logLog(LOG_ERR, dbLogFileID, __FILE__, __LINE__, __func__, LOG_TRANSACTION_PARAM_ERROR);
	+	rc_SQL = RC_DB_ERR;
	+	} // switch (transactionEnd)
	+
	+	logExitRC(LOG_INFO, dbLogFileID, __FILE__, __func__, rc_SQL);
	+	return rc_SQL;
	+	} // dbEndTransaction()
	+
	+	// EOF
	+	</code>
	+
	+	----
	+	Stand: 24.11.2010\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:esql_c:example:errorhandle

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:26+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== ErrorHandle ======

	+	Möchte man keine ausgefeilte (ESQL/C-)Fehlerbehandlung programmieren - für sehr kleine Programme durchaus sinvoll - kann ein einziger ErrorHandler (für alle Fehlersituationen) definiert werden.
	+
	+	Um diesen ErrorHandler den ESQL/C Librarys bekannt zu machen, reicht folgende Zeile (z.B. am Anfang der main()-Funktion):
	+
	+	<code sql>
	+	EXEC SQL WHENEVER ERROR CALL errorhandler;
	+	</code>
	+
	+	Für mehr Flexibilität definieren wir vorher die "errorhandler"-Funktion wie folgt:
	+
	+	<code c>
	+	#define errorhandler() _errorhandler_f_l(__FILE__, __LINE__)
	+	</code>
	+
	+	Die eigentliche "errorhandler"-Funktion kann dann in etwa so aussehen:
	+
	+	<code c>
	+	#define MSG_LEN 256
	+
	+	void _errorhandler_f_l (char * datei, int zeile)
	+	{
	+	char meldung[MSG_LEN];
	+	char meldung1[MSG_LEN];
	+	int i;
	+
	+	printf("ERROR in file %s, line %d:", datei, zeile);
	+	rgetlmsg(SQLCODE, meldung, MSG_LEN, &i);
	+	sprintf(meldung1, "SQL Error %d: %s", SQLCODE, meldung);
	+	printf(meldung1, sqlca.sqlerrm);
	+
	+	if (sqlca.sqlerrd[1])
	+	{
	+	rgetlmsg(sqlca.sqlerrd[1], meldung, MSG_LEN, &i);
	+	printf("ISAM Error %d: %s", sqlca.sqlerrd[1], meldung);
	+	} // if
	+
	+	exit(SQLCODE);
	+	} // _errorhandler_f_l()
	+	</code>
	+
	+	Das ganze führt dazu, daß das Programm bei Fehlern sofort abgebrochen wird. Vor dem Abbruch wird jedoch die "errorhandler"-Funktion aufgerufen, die ausführliche Informationen zur Ursache des Abbruchs mitteilt.
	+
	+	----
	+	Stand: 12.01.2011
	+
	+	EOF

edv:prg:esql_c:example:felder_der_sqlca-struktur

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:27+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Felder der sqlca-Struktur ======

	+	Die Beschreibung von Felder der sqlca-Struktur habe ich aus "IBM Informix ESQL/C Programmer's Manual".
	+
	+	Hier ist der Link zum kompletten und ausführlichen Originaldokument von IBM: [[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc214.htm\|Fields of the sqlca Structure]] (englisch)
	+
	+	Unten habe ich nur Felder zusammengefasst, die ich beim Zugriff auf eine Informix-DB aus einem C-Programm nützlich finde und auch verwende.
	+
	+	Die Struktur sqlca ist in sqlca.h definiert. Man braucht es jedoch nicht explizit im Programm zu include'n. Das tut der ESQL/C-Preprozessor von alleine.
	+
	+	\|Feld \|Typ \|Mögliche Werte \|Beschreibung\|
	+	\|sqlcode \|int4 \|0 \|Erfolg.\|
	+	\| \| \|>=0, <100 \|(Nach dem DESCRIBE-Statement.)\|
	+	\| \| \|100 \|'NOT FOUND' (Kein Fehler).\|
	+	\| \| \|<0 \|Fehler-Code.\|
	+	\|sqlerrd \|Array von 6 int4s \|[0] \|Nach dem erfolgreichen PREPARE-Statement (für SELECT, UPDATE, INSERT oder DELETE) oder nach dem (erfolgreichen) öffnen eines SELECT-Cursors, beinhaltet dieses Element die (geschätzte) Anzahl von Datensätze, die durch das Statement betroffen wären.\|
	+	\| \| \|[1] \|Zähler. Wenn sqlcode einen Fehler-Code aufweist, beinhaltet dieses Feld 0 oder einen zusätzlichen Fehler-Code.\\ Nach einem erfolgreichen INSERT eines einzigen Satzes beinhaltet dieses Feld den Wert eines serial-Feldes, der während des Inserts generiert wurde.\|
	+	\| \| \|[2] \|Zähler. Falls ein Statement mehrere (multirow) Datensätze auf einmal erfolgreich geändert hat (INSERT, UPDATE, oder DELETE), beinhaltet dieses Element die Anzahl von Sätzen, die durch das Statement betroffen wurden.\\ Falls INSERT, UPDATE, oder DELETE nicht fehlerfrei gelaufen war, beinhaltet dieses Element die Anzahl von Sätzen, die erfolgreich bearbeitet wurden, bevor der Fehler aufgetreten war.\|
	+
	+	EOF

edv:prg:esql_c:example:int_execsimplesql

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:26+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== execSimpleSQL() ======

	+	Es ist in einigen Situationen sinnvoll SQL-Statement dynamisch als String zu bilden und gleich bei der DB auszuführen. Solange solche Aufrufe einzeln und nicht wiederholt abgesetzt werden, sind sie genauso effizient wie die mit Prepared Statemens.
	+
	+	Hier ist ein Beispiel einer Funktion, die als Eingabeparameter einen beliebigen SQL-String erwartet (vereinfachte Variante):
	+
	+	<code c>
	+	#define RC_DB_OK 0
	+	#define TMP_STRING_LAENGE 8192
	+
	+	/*
	+	* Diese Funktion führt einfache SQLs aus.
	+	*
	+	* Eingabeparameter:
	+	* sql - SQL-String, der ausgeführt werden soll;
	+	* text - Text (z.B. updated / deleted / inserted) für Massenoperationen;
	+	* funktionname - "__func__"-Makro der aufrufenden Funktion (für den Trace)
	+	*
	+	* Ausgabeparameter:
	+	* rows - Falls NULL, wird ignoriert, sonst wird dort bei Erfolg die Zahl durch SQL betroffener Sätze zurück gegeben
	+	*/
	+	int execSimpleSQL (const char * sql, const int * rows, const char * text, const char * funktionname) // Führt einfache SQLs aus.
	+	{
	+	int rc_SQL = RC_DB_OK;
	+	int countRows = 0;
	+
	+	EXEC SQL BEGIN DECLARE SECTION;
	+	char tmpStrSQL [TMP_STRING_LAENGE + 1]; // Host-Variable (im Sinne ESQL/C)
	+	EXEC SQL END DECLARE SECTION;
	+
	+	countRows = 0;
	+	memset(tmpStrSQL, '\0', sizeof(tmpStrSQL));
	+
	+	strcpy(tmpStrSQL, sql); // Den SQL-String in die Host-Variable übernehmen.
	+
	+	// Hier wir die SQL-Anweisung ausgeführt:
	+	EXEC SQL EXECUTE IMMEDIATE :tmpStrSQL;
	+	if (rc_SQL = sqlca.sqlcode) rcSQL_ErrorInfo(tmpStrSQL, "fehlgeschlagen", rc_SQL, funktionname); // Fehlermeldung
	+	else
	+	{
	+	countRows = sqlca.sqlerrd[2]; // Anzahl betroffener Sätze übernehmen
	+
	+	if (text) printf("%d rows %s.", countRows, text); // Falls "text" nicht NULL, Text ausgeben.
	+
	+	if (rows) *rows = countRows; // Falls "rows" nicht NULL, Anzahl betroffener Sätze zurück geben.
	+	} // if
	+
	+	return rc_SQL;
	+	} // execSimpleSQL()
	+	</code>
	+
	+	Die Funktion rcSQL_ErrorInfo() gibt die Fehlermeldungen aus (vereinfachte Variante):
	+
	+	<code c>
	+	/*
	+	* Diese Funktion kann nach jeder DB-Operation aufgerufen werden,
	+	* falls der SQL-Code nicht RC_DB_OK ist.
	+	*
	+	* Eingabeparameter:
	+	* bezug - SQL-String, der den Fehler verursacht hat;
	+	* fehler - Fehlerinformation, z.B. das Wort "fehlgeschlagen"
	+	* rc_SQL - Fehler-Code der SQL-Operation
	+	* funktionname - s.o.
	+	*/
	+	void rcSQL_ErrorInfo (const char * bezug, const char * fehler, int rc_SQL, const char * funktionname)
	+	{
	+	printf("'%s' %s", bezug, fehler);
	+	printf("sqlca.sqlcode = %d (in %s)", rc_SQL, funktionname);
	+	} // rcSQL_ErrorInfo()
	+	</code>
	+
	+	----
	+	Stand: 26.11.2009\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

	aktuell
Zeile 1:	Zeile 1:
	+	====== Felder der sqlca-Struktur ======

	+	Die Beschreibung von Felder der sqlca-Struktur habe ich aus "IBM Informix ESQL/C Programmer's Manual".
	+
	+	Hier ist der Link zum kompletten und ausführlichen Originaldokument von IBM: [[http://publib.boulder.ibm.com/infocenter/idshelp/v10/index.jsp?topic=/com.ibm.esqlc.doc/esqlc214.htm\|Fields of the sqlca Structure]] (englisch)
	+
	+	Unten habe ich nur Felder zusammengefasst, die ich beim Zugriff auf eine Informix-DB aus einem C-Programm nützlich finde und auch verwende.
	+
	+	Die Struktur sqlca ist in sqlca.h definiert. Man braucht es jedoch nicht explizit im Programm zu include'n. Das tut der ESQL/C-Preprozessor von alleine.
	+
	+	\|Feld \|Typ \|Mögliche Werte \|Beschreibung\|
	+	\|sqlcode \|int4 \|0 \|Erfolg.\|
	+	\| \| \|>=0, <100 \|(Nach dem DESCRIBE-Statement.)\|
	+	\| \| \|100 \|'NOT FOUND' (Kein Fehler).\|
	+	\| \| \|<0 \|Fehler-Code.\|
	+	\|sqlerrd \|Array von 6 int4s \|[0] \|Nach dem erfolgreichen PREPARE-Statement (für SELECT, UPDATE, INSERT oder DELETE) oder nach dem (erfolgreichen) öffnen eines SELECT-Cursors, beinhaltet dieses Element die (geschätzte) Anzahl von Datensätze, die durch das Statement betroffen wären.\|
	+	\| \| \|[1] \|Zähler. Wenn sqlcode einen Fehler-Code aufweist, beinhaltet dieses Feld 0 oder einen zusätzlichen Fehler-Code.\\ Nach einem erfolgreichen INSERT eines einzigen Satzes beinhaltet dieses Feld den Wert eines serial-Feldes, der während des Inserts generiert wurde.\|
	+	\| \| \|[2] \|Zähler. Falls ein Statement mehrere (multirow) Datensätze auf einmal erfolgreich geändert hat (INSERT, UPDATE, oder DELETE), beinhaltet dieses Element die Anzahl von Sätzen, die durch das Statement betroffen wurden.\\ Falls INSERT, UPDATE, oder DELETE nicht fehlerfrei gelaufen war, beinhaltet dieses Element die Anzahl von Sätzen, die erfolgreich bearbeitet wurden, bevor der Fehler aufgetreten war.\|
	+
	+	EOF