Plan zajęć
- Interfejs JDBC
- Interfejs JDBC w przykładach
- Interfejs ODBC
CREATE SCHEMA lab11;
CREATE TABLE lab11.osoba ( id INT PRIMARY KEY,
fname VARCHAR(20), lname VARCHAR(20) );
javac {file}.java
java -cp .:./postgresql-42.2.27.jre7.jar {file}
Plik JDBC4_ConnDetail.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.SQLException;
import java.util.Arrays;
public class JDBC4_ConnDetail {
public static void main(String[] args) {
try {
String serverName = "localhost";
String dbase = "baza";
String url = "jdbc:postgresql://" + serverName + "/" + dbase;
Driver driver = DriverManager.getDriver(url);
// Get available properties
DriverPropertyInfo[] properties = driver.getPropertyInfo(url, null);
for (int i=0; i < properties.length; i++) {
// Property information
String name = properties[i].name;
boolean required = properties[i].required;
String value = properties[i].value;
String description = properties[i].description;
String[] choices = properties[i].choices;
System.out.println("Property : " + name + "\nRequired : " + required + "\nValue : " + value + "\nDescription : " + description + "\nChoices : " + (choices!=null?Arrays.asList(choices):null) + "\n");
}
} catch (SQLException e) {
System.out.println("Could not retrieve database metadata " + e.getMessage());
}
}
}
Plik JDBC4_Metadane.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class JDBC4_Metadane {
public static void main(String[ ] argv) {
System.out.println("Checking if Driver is registered with DriverManager.");
/* try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Couldn't find the driver!");
System.out.println("Let's print a stack trace, and exit.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Registered the driver ok, so let's make a connection.");
*/
Connection c = null;
try {
String dbaseURL = "jdbc:postgresql://localhost/baza";
String username = "***";
String password = "***";
c = DriverManager.getConnection (dbaseURL, username, password);
} catch (SQLException se) {
System.out.println("Couldn't connect: print out a stack trace and exit.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Hooray! We connected to the database!");
try {
DatabaseMetaData md; // metadane
// nalezy polaczyc sie z baza danych
md = c.getMetaData();
System.out.println("Database Product Name: "+md.getDatabaseProductName());
System.out.println("Database Product Version: "+md.getDatabaseProductVersion());
System.out.println("JDBC Driver: " + md.getDriverName());
System.out.println("Driver Version: " + md.getDriverVersion());
System.out.println("URL Database: " + md.getURL());
System.out.println("Logged User: " + md.getUserName());
md.supportsAlterTableWithAddColumn();
md.supportsAlterTableWithDropColumn();
md.supportsBatchUpdates();
md.supportsPositionedDelete();
md.supportsPositionedUpdate();
md.supportsTransactions();
md.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE);
md.supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE);
Statement st = c.createStatement();
ResultSet rs = st.executeQuery("SELECT fname,lname FROM lab11.osoba");
while (rs.next()) {
String fname = rs.getString("fname") ;
String lname = rs.getString("lname") ;
System.out.print("Columns returned ");
System.out.println(fname+" "+lname) ; }
rs.close();
st.close(); }
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("We should never get here."); }
}
Plik JDBC4_GetTables.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
public class JDBC4_GetTables {
public static void main(String[] args) {
Connection connection = null;
try {
String serverName = "localhost";
String schema = "baza";
String url = "jdbc:postgresql://" + serverName + "/" + schema;
String username = "***";
String password = "***";
connection = DriverManager.getConnection(url, username, password);
System.out.println("Successfully Connected to the database!");
} catch (SQLException e) {
System.out.println("Could not connect to the database " + e.getMessage());
}
try {
// Get the database metadata
DatabaseMetaData metadata = connection.getMetaData();
// Specify the type of object; in this case we want tables
String[] types = {"TABLE"};
ResultSet resultSet = metadata.getTables(null, null, "%", types);
while (resultSet.next()) {
String tableName = resultSet.getString(3);
String tableCatalog = resultSet.getString(1);
String tableSchema = resultSet.getString(2);
System.out.println("{ schema : '" + tableSchema + "', table : '" + tableName + "' catalog : '" + tableCatalog + "' }" );
}
} catch (SQLException e) {
System.out.println("Could not get database metadata " + e.getMessage());
}
}
}
CREATE OR REPLACE FUNCTION f1_osoba ( int ) RETURNS char(30) AS ' SELECT lname FROM lab11.osoba WHERE id = $1 ; ' LANGUAGE sql; CREATE OR REPLACE FUNCTION get_table() RETURNS table ( id int, fn char(30), ln char(30)) AS ' SELECT id, fname, lname FROM lab11.osoba ; ' LANGUAGE sql ; CREATE OR REPLACE FUNCTION get_cursor() RETURNS refcursor AS ' DECLARE curosoby refcursor ; BEGIN OPEN curosoby FOR SELECT id, fname, lname FROM lab11.osoba ; RETURN curosoby ; END; ' LANGUAGE plpgsql;
Plik jdbc_ex01.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex01 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Wykonanie zapytania SELSECT do bazy danych
// Wykorzystane elementy: prepareStatement(), executeQuery()
PreparedStatement pst = c.prepareStatement("SELECT id, fname, lname FROM lab11.osoba", ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pst.executeQuery();
while (rs.next()) {
//String pesel = rs.getString("pesel") ;
String imie = rs.getString("fname") ;
String nazwisko = rs.getString("lname") ;
System.out.print("Zwrocone kolumny ");
System.out.println(imie+" "+nazwisko) ; }
rs.close();
pst.close(); }
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
} Plik jdbc_ex02.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex02 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Wykonanie zapytania SELSECT do bazy danych
// Wykorzystane elementy: prepareStatement(), executeQuery()
PreparedStatement pst = c.prepareStatement("SELECT id, fname, lname FROM osoba", ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet rs = pst.executeQuery();
while (rs.next()) {
//String id = rs.getString("id") ;
String imie = rs.getString("fname") ;
String nazwisko = rs.getString("lname") ;
System.out.print("Zwrocone kolumny ");
System.out.println(imie+" "+nazwisko) ; }
rs.close();
pst.close(); }
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
Plik jdbc_ex03.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex03 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Wykonaie zapytania SELECT za warunkiem WHERE
// Wykorzystane elementy: setString, executeQuery
PreparedStatement pst = c.prepareStatement("SELECT id, fname, lname FROM lab11.osoba WHERE fname=?", ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
pst.setString(1,"Marek");
ResultSet rs ;
rs = pst.executeQuery();
while (rs.next()) {
//String id = rs.getString("id") ;
String imie = rs.getString("fname") ;
String nazwisko = rs.getString("lname") ;
System.out.print("Pytanie 1 - wynik: ");
System.out.println(imie+" "+nazwisko) ; }
rs.close();
pst.setString(1,"Bogdan");
rs = pst.executeQuery();
while (rs.next()) {
//String id = rs.getString("id") ;
String imie = rs.getString("fname") ;
String nazwisko = rs.getString("lname") ;
System.out.print("Pytanie 2 - wynik: ");
System.out.println(imie+" "+nazwisko) ; }
rs.close();
pst.close(); }
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
Plik jdbc_ex04.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex04 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Wstawianie rekordow do bazy danych
// Wykorzystanie metody executeUpdate()
PreparedStatement pst = c.prepareStatement( "INSERT INTO osoba (id, fname, lname) VALUES (?,?,?)" );
pst.setInt(1,7);
pst.setString(2,"Adam") ;
pst.setString(3,"Kowaski") ;
int rows ;
rows = pst.executeUpdate();
System.out.print("Polecenie 1 - INSERT - ilosc dodanych rekordow: ") ;
System.out.println(rows) ;
pst.setInt(1,8);
pst.setString(2,"Michal") ;
pst.setString(3,"Mamacki") ;
rows = pst.executeUpdate();
System.out.print("Polecenie 2 - INSERT - ilosc dodanych rekordow: ") ;
System.out.println(rows) ;
pst.close();
}
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
Plik jdbc_ex05.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex05 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Wykorzystanie obiektu CallableStatement i funkcji zwracajacej jeden rekord
//
CallableStatement cst = c.prepareCall( "{call lab11.f1_osoba(?)}" );
cst.setInt(1,1);
ResultSet rs ;
rs = cst.executeQuery();
while (rs.next()) {
// String pesel = rs.getString("pesel") ;
// String imie = rs.getString("imie") ;
String nazwisko = rs.getString(1) ;
System.out.print("Pytanie 1 - wynik: ");
System.out.println(nazwisko) ; }
rs.close();
cst.close();
}
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
Plik jdbc_ex06.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex06 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Statement st = c.createStatement();
// ResultSet rs = st.executeQuery("SELECT id, fname, lname FROM lab11.osoba");
//c.setAutoCommit(false) ;
CallableStatement cst = c.prepareCall( "{ call lab11.get_table() }" );
//cst.registerOutParameter(1,Types.OTHER) ;
cst.execute() ;
// System.out.println(cst.getObject(1)) ;
//ResultSet rs = (ResultSet) cst.getObject(1) ;
ResultSet rs = cst.executeQuery();
while (rs.next()) {
//Int pesel = rs.getInt(1) ;
String imie = rs.getString(2) ;
String nazwisko = rs.getString(3) ;
System.out.print("Pytanie 1 - wynik: ");
System.out.println(nazwisko + " " + imie) ; }
rs.close();
cst.close();
}
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
Plik jdbc_ex07.java ( [listing dokumentu] [link do dokumentu] )
import java.sql.*;
public class jdbc_ex07 {
public static void main(String[] argv) {
/*
System.out.println("Sprawdzenie czy sterownik jest zarejestrowany w menadzerze");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException cnfe) {
System.out.println("Nie znaleziono sterownika!");
System.out.println("Wyduk sledzenia bledu i zakonczenie.");
cnfe.printStackTrace();
System.exit(1);
}
System.out.println("Zarejstrowano sterownik - OK, kolejny krok nawiazanie polaczenia z baza danych.");
*/
Connection c = null;
try {
// Wymagane parametry polaczenia z baza danych:
// Pierwszy - URL do bazy danych:
// jdbc:dialekt SQL:serwer(adres + port)/baza w naszym przypadku:
// jdbc:postgres://pascal.fis.agh.edu.pl:5432/baza
// Drugi i trzeci parametr: uzytkownik bazy i haslo do bazy
c = DriverManager.getConnection("jdbc:postgresql://pascal.fis.agh.edu.pl:5432/baza",
"***", "***");
} catch (SQLException se) {
System.out.println("Brak polaczenia z baza danych, wydruk logu sledzenia i koniec.");
se.printStackTrace();
System.exit(1);
}
if (c != null) {
System.out.println("Polaczenie z baza danych OK ! ");
try {
// Statement st = c.createStatement();
// ResultSet rs = st.executeQuery("SELECT pesel, imie, nazwisko FROM osoba");
c.setAutoCommit(false) ;
CallableStatement cst = c.prepareCall( "{ ? = call lab11.get_cursor()}" );
cst.registerOutParameter(1, Types.OTHER) ;
cst.execute() ;
ResultSet rs = (ResultSet) cst.getObject(1);
while (rs.next()) {
Integer id = rs.getInt(1) ;
String id_s = Integer.toString(id);
String imie = rs.getString(2) ;
String nazwisko = rs.getString(3) ;
System.out.print("Pytanie 1 - wynik: ");
System.out.println( id_s + " " + imie + " " + nazwisko ) ; }
rs.close();
cst.close();
}
catch(SQLException e) {
System.out.println("Blad podczas przetwarzania danych:"+e) ; }
}
else
System.out.println("Brak polaczenia z baza, dalsza czesc aplikacji nie jest wykonywana."); }
}
odbcinst --version odbcinst -j
odbcinst -q -d
[DB1Lab] Description=PostgreSQL ANSI Driver=PostgreSQL ANSI Trace=No TraceFile= Database=Servername=localhost Username= Password= Port=5432 Protocol=16 ReadOnly=No RowVersioning=No ShowSystemTables=No ShowOidColumn=No FakeOidIndex=No ConnSettings=
odbcinst -q -s
gcc {file}.c -o {file} -lodbc
CREATE TABLE lab11.person ( id INT PRIMARY KEY,
fname VARCHAR(20), lname VARCHAR(20), email varchar(35) );
INSERT INTO lab11.person VALUES ( 1, 'Tadeusz', 'Abacki', 'abacki@onet.pl' ) ;
INSERT INTO lab11.person VALUES ( 2, 'Ewa', 'Babacka', 'babacka@google.com' ) ;
Plik odbc_info.c ( [listing dokumentu] [link do dokumentu] )
#include <stdio.h>
#include <sql.h>
#include <sqlext.h>
void main() {
SQLHENV env;
char driver[256];
char attr[256];
SQLSMALLINT driver_ret;
SQLSMALLINT attr_ret;
SQLUSMALLINT direction;
SQLRETURN ret;
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
direction = SQL_FETCH_FIRST;
while(SQL_SUCCEEDED(ret = SQLDrivers(env, direction,
driver, sizeof(driver), &driver_ret,
attr, sizeof(attr), &attr_ret))) {
direction = SQL_FETCH_NEXT;
printf("%s - %s\n", driver, attr);
if (ret == SQL_SUCCESS_WITH_INFO) printf("\tdata truncation\n");
}
}
Plik odbc_dsn.c ( [listing dokumentu] [link do dokumentu] )
#include <stdio.h>
#include <sql.h>
#include <sqlext.h>
void main() {
SQLHENV env;
char dsn[256];
char desc[256];
SQLSMALLINT dsn_ret;
SQLSMALLINT desc_ret;
SQLUSMALLINT direction;
SQLRETURN ret;
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
direction = SQL_FETCH_FIRST;
while(SQL_SUCCEEDED(ret = SQLDataSources(env, direction,
dsn, sizeof(dsn), &dsn_ret,
desc, sizeof(desc), &desc_ret))) {
direction = SQL_FETCH_NEXT;
printf("%s - %s\n", dsn, desc);
if (ret == SQL_SUCCESS_WITH_INFO) printf("\tdata truncation\n");
}
}
Plik odbc_conn.c ( [listing dokumentu] [link do dokumentu] )
#include <stdio.h>
#include <sql.h>
#include <sqlext.h>
void main() {
SQLHENV env;
SQLHDBC dbc;
SQLRETURN ret; /* ODBC API return status */
/* Allocate an environment handle */
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
/* We want ODBC 3 support */
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
/* Allocate a connection handle */
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
/* Connect to the DSN mydsn */
ret = SQLDriverConnect(dbc, NULL, "DSN=test1;", SQL_NTS,
NULL, 0, NULL,
SQL_DRIVER_COMPLETE);
if (SQL_SUCCEEDED(ret)) {
SQLCHAR dbms_name[256], dbms_ver[256];
SQLUINTEGER getdata_support;
SQLUSMALLINT max_concur_act;
SQLSMALLINT string_len;
printf("Connected\n");
/*
* Find something out about the driver.
*/
SQLGetInfo(dbc, SQL_DBMS_NAME, (SQLPOINTER)dbms_name,
sizeof(dbms_name), NULL);
SQLGetInfo(dbc, SQL_DBMS_VER, (SQLPOINTER)dbms_ver,
sizeof(dbms_ver), NULL);
SQLGetInfo(dbc, SQL_GETDATA_EXTENSIONS, (SQLPOINTER)&getdata_support,
0, 0);
SQLGetInfo(dbc, SQL_MAX_CONCURRENT_ACTIVITIES, &max_concur_act, 0, 0);
printf("DBMS Name: %s\n", dbms_name);
printf("DBMS Version: %s\n", dbms_ver);
if (max_concur_act == 0) {
printf("SQL_MAX_CONCURRENT_ACTIVITIES - no limit or undefined\n");
} else {
printf("SQL_MAX_CONCURRENT_ACTIVITIES = %u\n", max_concur_act);
}
if (getdata_support & SQL_GD_ANY_ORDER)
printf("SQLGetData - columns can be retrieved in any order\n");
else
printf("SQLGetData - columns must be retrieved in order\n");
if (getdata_support & SQL_GD_ANY_COLUMN)
printf("SQLGetData - can retrieve columns before last bound one\n");
else
printf("SQLGetData - columns must be retrieved after last bound one\n");
SQLDisconnect(dbc); /* disconnect from driver */
} else {
fprintf(stderr, "Failed to connect\n");
}
/* free up allocated handles */
SQLFreeHandle(SQL_HANDLE_DBC, dbc);
SQLFreeHandle(SQL_HANDLE_ENV, env);
}
Plik odbc_read.c ( [listing dokumentu] [link do dokumentu] )
#include <stdio.h>
#include <sql.h>
#include <sqlext.h>
#include <string.h>
void main() {
SQLHENV env;
SQLHDBC dbc;
SQLHSTMT stmt;
SQLRETURN ret; /* ODBC API return status */
SQLSMALLINT columns; /* number of columns in result-set */
int row = 0;
/* Allocate an environment handle */
SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
/* We want ODBC 3 support */
SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
/* Allocate a connection handle */
SQLAllocHandle(SQL_HANDLE_DBC, env, &dbc);
/* Connect to the DSN mydsn */
/* You will need to change mydsn to one you have created and tested */
SQLDriverConnect(dbc, NULL, "DSN=test1;", SQL_NTS,
NULL, 0, NULL, SQL_DRIVER_COMPLETE);
/* Allocate a statement handle */
SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
/* Retrieve a list of tables */
SQLTables(stmt, NULL, 0, NULL, 0, NULL, 0, "TABLE", SQL_NTS);
/* How many columns are there */
SQLNumResultCols(stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
printf("Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
char buf[512];
/* retrieve column data as a string */
ret = SQLGetData(stmt, i, SQL_C_CHAR,
buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy(buf, "NULL");
printf(" Column %u : %s\n", i, buf);
}
}
}
}
Plik odbc_select.c ( [listing dokumentu] [link do dokumentu] )
#include <stdio.h>
#include <stdlib.h>
#include <sql.h>
#include <sqlext.h>
#include <string.h>
void HandleDiagnosticRecord(SQLHANDLE,SQLSMALLINT,RETCODE);
#define SQL_QUERY_SIZE 1000
#define PARAM_ARRAY_SIZE 2
int main()
{
SQLHENV hEnv = NULL;
SQLHDBC hDbc = NULL;
SQLHSTMT hStmt = NULL;
//WCHAR* pwszConnStr;
//WCHAR wszInput[SQL_QUERY_SIZE];
CHAR* pwszConnStr;
CHAR wszInput[SQL_QUERY_SIZE];
SQLRETURN ret;
//char tmpbuf[256];
int row = 0;
SQLINTEGER uczestnikID[] = { 1,2 };
SQLUSMALLINT ParamStatusArray[PARAM_ARRAY_SIZE];
SQLLEN ParamsProcessed = 0;
// Allocate an environment
if (SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv) == SQL_ERROR)
{
fprintf(stderr, "Unable to allocate an environment handle\n");
exit(-1);
}
// Register this as an application that expects 3.x behavior,
// Allocate a connection
RETCODE rc = SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0);
if (rc != SQL_SUCCESS)
{
HandleDiagnosticRecord(hEnv, SQL_HANDLE_ENV, rc);
}
if (rc == SQL_ERROR)
{
fprintf(stderr, "Error in SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3,0)\n");
exit(-1);
}
rc = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc);
if (rc != SQL_SUCCESS)
{
HandleDiagnosticRecord(hEnv, SQL_HANDLE_ENV, rc);
}
if (rc == SQL_ERROR)
{
fprintf(stderr, "Error in SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3,0)\n");
goto Exit;
}
pwszConnStr = "BD1Lab";
rc = SQLConnect(hDbc, pwszConnStr, SQL_NTS, NULL, 0, NULL, 0);
fprintf(stderr, "Connected!\n");
rc = SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt);
strcpy(wszInput, "SELECT fname, lname, email FROM lab11.person WHERE id = ?;");
RETCODE RetCode;
SQLSMALLINT sNumResults;
// Execute the query
// Prepare Statement
//RetCode = SQLPrepare(hStmt, wszInput, SQL_NTS);
RetCode = SQLSetStmtAttr(hStmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER)PARAM_ARRAY_SIZE, 0);
RetCode = SQLSetStmtAttr(hStmt, SQL_ATTR_PARAM_STATUS_PTR, ParamStatusArray, PARAM_ARRAY_SIZE);
RetCode = SQLSetStmtAttr(hStmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &ParamsProcessed, 0);
// Bind array values of parameter 1
RetCode = SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_LONG,
SQL_INTEGER, 0, 0, uczestnikID, 0, NULL);
RetCode = SQLExecDirect(hStmt, wszInput, SQL_NTS);
//RetCode = SQLExecute(hStmt);
//RetCode = SQLExecDirect(hStmt, wszInput, SQL_NTS);
// Retrieve number of columns
rc = SQLNumResultCols(hStmt, &sNumResults);
//printf("Number of Result Columns %i\n", sNumResults);
switch (RetCode)
{
case SQL_SUCCESS_WITH_INFO:
{
HandleDiagnosticRecord(hStmt, SQL_HANDLE_STMT, RetCode);
}
case SQL_SUCCESS:
{
rc = SQLNumResultCols(hStmt, &sNumResults);
if (sNumResults > 0)
{
//DisplayResults(hStmt, sNumResults);
while (SQL_SUCCEEDED(ret = SQLFetch(hStmt))) {
SQLUSMALLINT i;
printf("Row %d\n", row++);
// Loop through the columns
for (i = 1; i <= sNumResults; i++) {
SQLLEN indicator;
//SQLWCHAR buf[512];
SQLCHAR buf[512];
// retrieve column data as a string
ret = SQLGetData(hStmt, i, SQL_C_CHAR, buf, sizeof(buf), &indicator);
//ret = SQLGetData(hStmt, i, SQL_C_WCHAR, buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
// Handle null columns
if (indicator == SQL_NULL_DATA) strcpy(buf, "NULL");
printf(" Column %u : %s\n", i, buf);
}
}
}
}
else
{
SQLLEN cRowCount;
rc = SQLRowCount(hStmt, &cRowCount);
if (cRowCount >= 0)
{
printf("%d %s affected\n", cRowCount, cRowCount == 1 ? "row" : "rows");
}
}
break;
}
case SQL_ERROR:
{
HandleDiagnosticRecord(hStmt, SQL_HANDLE_STMT, RetCode);
break;
}
default:
fprintf(stderr, "Unexpected return code %hd!\n", RetCode);
}
rc = SQLFreeStmt(hStmt, SQL_CLOSE);
Exit:
if (hStmt)
{
SQLFreeHandle(SQL_HANDLE_STMT, hStmt);
}
if (hDbc)
{
SQLDisconnect(hDbc);
SQLFreeHandle(SQL_HANDLE_DBC, hDbc);
}
if (hEnv)
{
SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
}
printf("\nUFF - wykonane\n");
return 0;
}
//
void HandleDiagnosticRecord(SQLHANDLE hHandle,
SQLSMALLINT hType,
RETCODE RetCode)
{
SQLSMALLINT iRec = 0;
SQLINTEGER iError;
//WCHAR wszMessage[1000];
//WCHAR wszState[SQL_SQLSTATE_SIZE + 1];
CHAR wszMessage[1000];
CHAR wszState[SQL_SQLSTATE_SIZE + 1];
if (RetCode == SQL_INVALID_HANDLE)
{
fprintf(stderr, "Invalid handle!\n");
return;
}
while (SQLGetDiagRec(hType, hHandle, ++iRec, wszState,
&iError, wszMessage,
(SQLSMALLINT)(sizeof(wszMessage) / sizeof(WCHAR)),
(SQLSMALLINT *)NULL) == SQL_SUCCESS)
{
// Hide data truncated..
if (strncmp(wszState, "01004", 5))
{
fprintf(stderr, "[%5.5s] %s (%d)\n", wszState, wszMessage, iError);
}
}
}
Plik odbc_update.c ( [listing dokumentu] [link do dokumentu] )
/**********************************************************************
* odbc_insert_update.c
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <sql.h>
#include <sqlext.h>
#include <string.h>
void print_odbc_error(char *fn, SQLHANDLE handle, SQLSMALLINT type);
#define LNAME_LEN 255
#define FNAME_LEN 255
#define EMAIL_LEN 255
#define TRUE 1
#define FALSE 0
SQLLEN newID;
SQLLEN uczestnikID;
SQLCHAR fname[FNAME_LEN];
SQLCHAR lname[LNAME_LEN];
SQLCHAR email[EMAIL_LEN];
SQLCHAR updtemail[EMAIL_LEN];
SQLLEN lennewID=0, lenFirstName=0, lenLastName=0, lenEmail=0;
int main () {
// deklaracje uchwytow - handle for:
SQLHENV henv = SQL_NULL_HENV; // Environment
SQLHDBC hdbc = SQL_NULL_HDBC; // Connection
SQLHSTMT hInsertStmt = SQL_NULL_HSTMT; // Insert statement
SQLHSTMT hUpdateStmt = SQL_NULL_HSTMT; // Update statement
SQLRETURN retcode;
// Allocate environment
retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLAllocHandle(SQL_HANDLE_ENV)", henv, SQL_HANDLE_ENV);
goto exit;
}
// Set ODBC version
retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION,
(SQLPOINTER*)SQL_OV_ODBC3, 0);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLSetEnvAttr(SQL_ATTR_ODBC_VERSION)", henv, SQL_HANDLE_ENV);
goto exit;
}
// Allocate connection
retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLAllocHandle(SQL_HANDLE_DBC)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
// Set Login Timeout
retcode = SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLSetConnectAttr(SQL_LOGIN_TIMEOUT)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
//retcode = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)TRUE, 0);
retcode = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)FALSE, 0);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLSetConnectAttr(SQL_ATTR_AUTOCOMMIT)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
// Connect to DSN
retcode = SQLConnect(hdbc, (SQLCHAR*) "BD1Lab", SQL_NTS,
(SQLCHAR*) NULL, 0, NULL, 0);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLConnect(DSN BD1Lab)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
// Allocate Statement Handle
retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hInsertStmt);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLAllocHandle(SQL_HANDLE_STMT)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hUpdateStmt);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLAllocHandle(SQL_HANDLE_STMT)", hUpdateStmt, SQL_HANDLE_STMT);
goto exit;
}
// Bind Parameters to all fields
retcode = SQLBindParameter(hInsertStmt, 1,
SQL_PARAM_INPUT, SQL_C_CHAR,
SQL_VARCHAR, FNAME_LEN, 0,
fname, FNAME_LEN, &lenFirstName);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(1)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLBindParameter(hInsertStmt, 2,
SQL_PARAM_INPUT, SQL_C_CHAR,
SQL_VARCHAR, LNAME_LEN, 0,
lname, LNAME_LEN, &lenLastName);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(2)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLBindParameter(hInsertStmt, 3,
SQL_PARAM_INPUT, SQL_C_CHAR,
SQL_VARCHAR, EMAIL_LEN, 0,
email, EMAIL_LEN, &lenEmail);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(3)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLBindParameter(hInsertStmt, 4,
SQL_PARAM_INPUT, SQL_C_ULONG,
SQL_INTEGER, 0, 0,
&newID, 0, NULL);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(4)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLBindParameter(hUpdateStmt, 1,
SQL_PARAM_INPUT, SQL_C_CHAR,
SQL_VARCHAR, EMAIL_LEN, 0,
updtemail, EMAIL_LEN, &lenEmail);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(1)", hUpdateStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLBindParameter(hUpdateStmt, 2,
SQL_PARAM_INPUT, SQL_C_ULONG,
SQL_INTEGER, 0, 0,
&uczestnikID, 0, NULL);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(2)", hUpdateStmt, SQL_HANDLE_STMT);
goto exit;
}
// Prepare INSERT AND UPDATE
retcode = SQLPrepare(hUpdateStmt, (SQLCHAR*)
"UPDATE lab11.person SET email = ? WHERE id = ?", SQL_NTS);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLPrepare(UPDATE)", hUpdateStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLPrepare(hInsertStmt, (SQLCHAR*)
"INSERT INTO lab11.person (lname, fname, email, id)"
"VALUES (?, ?, ?, ?)", SQL_NTS);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLPrepare(INSERT)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
strcpy(fname, "Adam");
strcpy(lname, "Kowalski");
strcpy(email, "kowalski@student.agh.edu.pl");
strcpy(updtemail, "kowalski@fis.agh.edu.pl");
newID = 5;
uczestnikID = 5;
// Set lengths to field lengths
lenFirstName=sizeof(fname);
lenLastName=sizeof(lname);
lenEmail=sizeof(email);
retcode = SQLExecute(hInsertStmt);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLExecute(INSERT)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLExecute(hUpdateStmt);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLExecute(UPDATE)", hUpdateStmt, SQL_HANDLE_STMT);
goto exit;
}
// retcode = SQLExecute(hInsertStmt);
// if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
// {
// print_odbc_error("SQLExecute(INSERT)", hInsertStmt, SQL_HANDLE_STMT);
// goto exit;
// }
retcode = SQLEndTran (SQL_HANDLE_DBC, hdbc, SQL_COMMIT);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLEndTran(SQL_COMMIT)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
printf ("Transaction Committed (status %i)\n", retcode);
//retcode = SQLEndTran (SQL_HANDLE_DBC, hdbc, SQL_ROLLBACK);
// if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
// {
// print_odbc_error("SQL_HANDLE_DBC(SQL_ROLLBACK)", hdbc, SQL_HANDLE_DBC);
// goto exit;
// }
//printf ("Rollback Transaction (status %i)\n", retcode);
// free handles
retcode = SQLFreeStmt(hInsertStmt, SQL_CLOSE);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLFreeStmt()", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
// Read modified data
retcode = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)TRUE, 0);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLSetConnectAttr(SQL_ATTR_AUTOCOMMIT)", hdbc, SQL_HANDLE_DBC);
goto exit;
}
retcode = SQLBindParameter(hInsertStmt, 1,
SQL_PARAM_INPUT, SQL_C_ULONG,
SQL_INTEGER, 0, 0,
&newID, 0, NULL);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLBindParameter(1)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
retcode = SQLExecDirect(hInsertStmt, (SQLCHAR *)
"SELECT id, lname, fname, email FROM lab11.person WHERE id = ?", SQL_NTS);
if (retcode!=SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO)
{
print_odbc_error("SQLExecDirect(SELECT)", hInsertStmt, SQL_HANDLE_STMT);
goto exit;
}
for ( retcode = SQLFetch(hInsertStmt) ;
retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ;
retcode = SQLFetch(hInsertStmt) ) {
memset(fname, ' ', FNAME_LEN);
retcode = SQLGetData(hInsertStmt, 1, SQL_C_USHORT,
(SQLPOINTER)&newID, 0, NULL);
retcode = SQLGetData(hInsertStmt, 2, SQL_C_CHAR,
fname, FNAME_LEN, &lenFirstName);
retcode = SQLGetData(hInsertStmt, 3, SQL_C_CHAR,
lname, LNAME_LEN, &lenLastName);
retcode = SQLGetData(hInsertStmt, 4, SQL_C_CHAR,
email, EMAIL_LEN, &lenEmail);
printf ("\nid : %i", (int)newID);
printf ("\nimie : %.30s", fname);
printf ("\nnazwisko : %.30s", lname);
printf ("\nemail : %.50s", email);
}
exit:
printf ("\nUFF.\n");
// Free handles
// Statement
if (hInsertStmt != SQL_NULL_HSTMT)
SQLFreeHandle(SQL_HANDLE_STMT, hInsertStmt);
if (hUpdateStmt != SQL_NULL_HSTMT)
SQLFreeHandle(SQL_HANDLE_STMT, hUpdateStmt);
// Connection
if (hdbc != SQL_NULL_HDBC) {
SQLDisconnect(hdbc);
SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
}
// Environment
if (henv != SQL_NULL_HENV)
SQLFreeHandle(SQL_HANDLE_ENV, henv);
return 0;
}
// print_error
void print_odbc_error(char *fn, SQLHANDLE handle, SQLSMALLINT type)
{
SQLINTEGER i = 0;
SQLINTEGER NativeError;
SQLCHAR SQLState[ 7 ];
SQLCHAR MessageText[256];
SQLSMALLINT TextLength;
SQLRETURN ret;
fprintf(stderr, "\nError %s\n", fn);
do
{
ret = SQLGetDiagRec(type, handle, ++i, SQLState, &NativeError,
MessageText, sizeof(MessageText), &TextLength);
if (SQL_SUCCEEDED(ret)) {
printf("%s:%ld:%ld:%s\n",
SQLState, (long) i, (long) NativeError, MessageText);
}
}
while( ret == SQL_SUCCESS );
}