pgObject *edbPrivateSynonymFactory::CreateObjects(pgCollection *collection, ctlTree *browser, const wxString &restriction)
{
edbPrivateSynonym *synonym=0;
wxString sql = wxT("SELECT s.*, pg_get_userbyid(s.synowner) AS owner,\n")
wxT(" COALESCE((SELECT relkind \n")
wxT(" FROM pg_class c, pg_namespace n\n")
wxT(" WHERE c.relnamespace = n.oid\n")
wxT(" AND n.nspname = s.synobjschema\n")
wxT(" AND c.relname = s.synobjname), '') AS targettype\n")
wxT(" FROM pg_synonym s\n")
wxT(" JOIN pg_namespace ns ON s.synnamespace = ns.oid AND ns.nspname = ")
+ qtConnString(collection->GetSchema()->GetName()) + wxT(" \n")
+ restriction +
wxT(" ORDER BY synname;");
pgSet *synonyms = collection->GetDatabase()->ExecuteSet(sql);
if (synonyms)
{
while (!synonyms->Eof())
{
wxString name=synonyms->GetVal(wxT("synname"));
synonym = new edbPrivateSynonym(collection->GetSchema(), name);
synonym->iSetDatabase(collection->GetDatabase());
synonym->iSetOwner(synonyms->GetVal(wxT("owner")));
if (synonyms->GetVal(wxT("targettype")) == wxT("r"))
synonym->iSetTargetType(_("Table"));
else if (synonyms->GetVal(wxT("targettype")) == wxT("S"))
synonym->iSetTargetType(_("Sequence"));
else if (synonyms->GetVal(wxT("targettype")) == wxT("v"))
synonym->iSetTargetType(_("View"));
else
synonym->iSetTargetType(_("Synonym"));
synonym->iSetTargetSchema(synonyms->GetVal(wxT("synobjschema")));
synonym->iSetTargetObject(synonyms->GetVal(wxT("synobjname")));
if (browser)
{
browser->AppendObject(collection, synonym);
synonyms->MoveNext();
}
else
break;
}
delete synonyms;
}
return synonym;
}
pgConn::pgConn(const wxString &server, const wxString &service, const wxString &hostaddr, const wxString &database, const wxString &username, const wxString &password,
int port, const wxString &rolename, int sslmode, OID oid, const wxString &applicationname,
const wxString &sslcert, const wxString &sslkey, const wxString &sslrootcert, const wxString &sslcrl,
const bool sslcompression) : m_cancelConn(NULL)
{
wxString msg;
save_server = server;
save_hostaddr = hostaddr;
save_service = service;
save_database = database;
save_username = username;
save_password = password;
save_port = port;
save_rolename = rolename;
save_sslmode = sslmode;
save_oid = oid;
save_applicationname = applicationname;
save_sslcert = sslcert;
save_sslkey = sslkey;
save_sslrootcert = sslrootcert;
save_sslcrl = sslcrl;
save_sslcompression = sslcompression;
memset(features, 0, sizeof(features));
majorVersion = 0;
conv = &wxConvLibc;
needColQuoting = false;
utfConnectString = false;
// Check the hostname/ipaddress
conn = 0;
noticeArg = 0;
connStatus = PGCONN_BAD;
// Create the connection string
if (!server.IsEmpty())
{
connstr.Append(wxT(" host="));
connstr.Append(qtConnString(server));
}
if (!hostaddr.IsEmpty())
{
connstr.Append(wxT(" hostaddr="));
connstr.Append(qtConnString(hostaddr));
}
if (!service.IsEmpty())
{
connstr.Append(wxT(" service="));
connstr.Append(qtConnString(service));
}
if (!database.IsEmpty())
{
connstr.Append(wxT(" dbname="));
connstr.Append(qtConnString(database));
}
if (!username.IsEmpty())
{
connstr.Append(wxT(" user="******" password="******" port="));
connstr.Append(NumToStr((long)port));
}
if (libpqVersion > 7.3)
{
switch (sslmode)
{
case 1:
connstr.Append(wxT(" sslmode=require"));
break;
case 2:
connstr.Append(wxT(" sslmode=prefer"));
break;
case 3:
connstr.Append(wxT(" sslmode=allow"));
break;
case 4:
connstr.Append(wxT(" sslmode=disable"));
break;
case 5:
connstr.Append(wxT(" sslmode=verify-ca"));
break;
case 6:
connstr.Append(wxT(" sslmode=verify-full"));
break;
}
}
else
{
switch (sslmode)
{
case 1:
connstr.Append(wxT(" requiressl=1"));
break;
case 2:
connstr.Append(wxT(" requiressl=0"));
break;
}
}
if (libpqVersion > 8.3 && sslmode != 4)
{
if (!sslcert.IsEmpty())
{
connstr.Append(wxT(" sslcert="));
connstr.Append(qtConnString(sslcert));
}
if (!sslkey.IsEmpty())
{
connstr.Append(wxT(" sslkey="));
connstr.Append(qtConnString(sslkey));
}
if (!sslrootcert.IsEmpty())
{
connstr.Append(wxT(" sslrootcert="));
connstr.Append(qtConnString(sslrootcert));
}
if (!sslcrl.IsEmpty())
{
connstr.Append(wxT(" sslcrl="));
connstr.Append(qtConnString(sslcrl));
}
}
if (libpqVersion > 9.1 && sslmode != 4)
{
if (!sslcompression)
{
connstr.Append(wxT(" sslcompression=0"));
}
}
connstr.Trim(false);
dbHost = server;
dbHostName = server;
dbRole = rolename;
#ifdef HAVE_CONNINFO_PARSE
if (!applicationname.IsEmpty())
{
// Check connection string with application_name
char *errmsg;
wxString connstr_with_applicationname = connstr + wxT(" application_name='") + applicationname + wxT("'");
if (PQconninfoParse(connstr_with_applicationname.mb_str(wxConvUTF8), &errmsg))
{
connstr = connstr_with_applicationname;
}
else if (PQconninfoParse(connstr_with_applicationname.mb_str(wxConvLibc), &errmsg))
{
connstr = connstr_with_applicationname;
}
}
#endif
// Open the connection
wxString cleanConnStr = connstr;
cleanConnStr.Replace(qtConnString(password), wxT("'XXXXXX'"));
wxLogInfo(wxT("Opening connection with connection string: %s"), cleanConnStr.c_str());
DoConnect();
}
void dbgPgConn::Init( const wxString &server, const wxString &database, const wxString &username, const wxString &password, const wxString &port, int sslmode, const wxString &applicationname, bool startThread )
{
bool utfConnectString = false;
bool libcConnectString = false;
m_pgConn = NULL;
m_majorVersion = 0;
m_minorVersion = 0;
m_debuggerApiVersion = DEBUGGER_UNKNOWN_API;
m_isEdb = false;
if( startThread )
m_workerThread = new dbgPgThread( *this );
else
m_workerThread = NULL;
wxString msg;
wxString delimiter;
// To keep the user interface thread responsive while we're waiting for the
// PostgreSQL server, we create a separate thread to interact with the
// database - the worker thread sleeps until the GUI thread signals that it
// has some work to do. When the result set arrives from the server, the
// worker thread creates a DBResult event and posts it to the GUI thread's
// event queue.
if( m_workerThread )
{
m_workerThread->Create();
m_workerThread->Run();
}
// Figure out the hostname/IP address
struct hostent *host;
in_addr_t addr;
wxString hostip, hostname;
#ifdef __WXMSW__
struct in_addr ipaddr;
#else
unsigned long ipaddr;
#endif
#ifndef __WXMSW__
if (!(server.IsEmpty() || server.StartsWith(wxT("/"))))
{
#endif
addr = inet_addr(server.ToAscii());
if (addr == INADDR_NONE) // szServer is not an IP address
{
host = gethostbyname(server.ToAscii());
if (host == NULL)
{
wxLogError(__("Could not resolve hostname %s"), server.c_str());
return;
}
memcpy(&(ipaddr), host->h_addr, host->h_length);
hostip = wxString::FromAscii(inet_ntoa(*((struct in_addr *) host->h_addr_list[0])));
hostname = server;
}
else
{
hostip = server;
hostname = server;
}
#ifndef __WXMSW__
}
else
hostname = server;
#endif
// Build up a connection string
wxString connectParams;
if(hostname.Length())
{
connectParams.Append(wxT( "host="));
connectParams.Append(hostname);
msg += delimiter + server;
delimiter = _(":");
}
if (hostip.Length())
{
connectParams.Append(wxT(" hostaddr="));
connectParams.Append(hostip);
}
if(port.Length())
{
connectParams += wxT(" port=");
connectParams += port;
msg += delimiter + port;
delimiter = _(":");
}
if(database.Length())
{
connectParams.Append(wxT(" dbname="));
connectParams.Append(qtConnString(database));
msg += delimiter + database;
delimiter = _(":");
}
if(username.Length())
{
connectParams.Append(wxT(" user="******":");
}
if(password.Length())
{
connectParams.Append(wxT(" password="******" sslmode=require"));
break;
case 2:
connectParams.Append(wxT(" sslmode=prefer"));
break;
case 3:
connectParams.Append(wxT(" sslmode=allow"));
break;
case 4:
connectParams.Append(wxT(" sslmode=disable"));
break;
case 5:
connectParams.Append(wxT(" sslmode=verify-ca"));
break;
case 6:
connectParams.Append(wxT(" sslmode=verify-full"));
break;
default:
break;
}
connectParams.Trim(true);
connectParams.Trim(false);
#ifdef HAVE_CONNINFO_PARSE
if (!applicationname.IsEmpty())
{
// Check connection string with application_name
char *errmsg;
wxString connectParams_with_applicationname = connectParams + wxT(" application_name='") + applicationname + wxT("'");
if (PQconninfoParse(connectParams_with_applicationname.mb_str(wxConvUTF8), &errmsg))
{
utfConnectString = true;
connectParams = connectParams_with_applicationname;
}
else if (PQconninfoParse(connectParams_with_applicationname.mb_str(wxConvLibc), &errmsg))
{
libcConnectString = true;
connectParams = connectParams_with_applicationname;
}
}
#endif
m_frame->getStatusBar()->SetStatusText( wxString::Format(_( "Connecting to %s" ), msg.c_str()), 1 );
wxCharBuffer cstrUTF = connectParams.mb_str(wxConvUTF8);
wxCharBuffer cstrLibc = connectParams.mb_str(wxConvLibc);
if (!libcConnectString)
m_pgConn = PQconnectdb(cstrUTF);
else
m_pgConn = PQconnectdb(cstrLibc);
if (PQstatus(m_pgConn) != CONNECTION_OK)
{
PQfinish(m_pgConn);
m_pgConn = PQconnectdb(cstrLibc);
}
if( PQstatus( m_pgConn ) == CONNECTION_OK )
{
m_frame->getStatusBar()->SetStatusText( wxString::Format(_( "Connected to %s" ), msg.c_str()), 1 );
PQsetClientEncoding( m_pgConn, "UNICODE" );
}
else
{
throw( std::runtime_error( PQerrorMessage( m_pgConn )));
}
}
