/* RCS $Id: CosQuery.idl,v 1.1 1998/11/17 03:10:35 scrappy Exp $

*

* ----------------------------------------------------------------------------

* This is unmarked software provided by the Object Management Group,Inc. (OMG)

* ----------------------------------------------------------------------------

*/

/**

* CosQuery is the Common Object Services Specification query module

* as it it appears in COSS1, v1.0.

*/

#ifndef CosQuery_idl

#define CosQuery_idl

#ifndef CosQueryCollection_idl

#include "CosQueryCollection.idl"

#endif

module CosQuery {

exception QueryInvalid {string why;};

exception QueryProcessingError {string why;};

exception QueryTypeInvalid {};

enum QueryStatus {complete, incomplete};

typedef CosQueryCollection::ParameterList ParameterList;

typedef CORBA::InterfaceDef QLType;

typedef sequence<QLType> QLTypeSeq;

interface Query;

interface QueryLanguageType {};

interface SQLQuery : QueryLanguageType {};

interface SQL_92Query : SQLQuery {};

interface OQL : QueryLanguageType {};

interface OQLBasic : OQL {};

interface OQL_93 : OQL {};

interface OQL_93Basic : OQL_93, OQLBasic {};

interface QueryEvaluator {

readonly attribute QLTypeSeq ql_types;

readonly attribute QLType default_ql_type;

any evaluate (in string query,

in QLType ql_type,

in ParameterList params)

raises(QueryTypeInvalid,

QueryInvalid,

QueryProcessingError);

};

interface QueryableCollection : QueryEvaluator,

CosQueryCollection::Collection {

};

interface QueryManager : QueryEvaluator {

Query create (in string query,

in QLType ql_type,

in ParameterList params)

raises(QueryTypeInvalid,

QueryInvalid);

};

interface Query {

readonly attribute QueryManager query_mgr;

void prepare (in ParameterList params)

raises(QueryProcessingError);

void execute (in ParameterList params)

raises(QueryProcessingError);

QueryStatus get_status ();

any get_result ();

};

};

#endif // CosQuery_idl

#include "CosQueryCollection.idl"

#ifndef pgsql_idl

#define pgsql_idl

#ifndef CosQuery_idl

#include "CosQuery.idl"

#endif

#ifndef CosQueryCollection_idl

#include "CosQueryCollection.idl"

#endif

module PostgreSQL {

// Built-in types

module Types {

// Arrays in network order

typedef short int2;

typedef long int4;

typedef long int8[2];

};

// NULL support

typedef boolean Null;

union Value switch (Null) {

case false: any value;

};

typedef sequence<Value> Row;

// <info>

// More about the application of COSS:

//

// A Table will be a QueryableCollection of Rows

// A Database will be a QueryableCollection of Tables

// Both will be queryable via the Query Service

//

// Other relations will be representable using the Relationship Service

// This includes primary/foreign keys and anything else :)

//

// GRANT/REVOKE can be supplied via the Security Service

//

// See a pattern here? The whole of SQL can be implemented by these services!

// The statements go through a parser. Queries and subqueries are passed to the

// database for processing. Returned items are handled appropriately:

//

// SELECT: return the items to the caller

// UPDATE: modify the items (direct)

// DELETE: call delete() on each Row (direct)

// GRANT/REVOKE: modify ACLs (via Security Service)

// ALTER: modify the items (direct) and/or the relations (via Relationship Service)

// etc.

//

// I'm not sure yet about LOCK and UNLOCK.

// </info>

// Query result interface

//

// Should the iterator support a 'boolean skip(in long n)' extension?

interface QueryResult : CosQueryCollection::Collection {};

interface QueryResultIterator : CosQueryCollection::Iterator {};

// Connected database object

interface Database {

QueryResult exec(in string query);

void disconnect();

};

// Server object (stateless)

interface Server {

Database connect(in string db, in string user, in string password);

};

// Built-in types

module Types {

// Arrays in network order

typedef short int2;

typedef long int4;

typedef long int8[2];

};

// NULL support

typedef boolean Null;

union Value switch (Null) {

case false: any value;

};

// Row definition

typedef sequence<Value> Row;

// <info>

// More about the application of COSS:

//

// A Table will be a QueryableCollection of Rows

// A Database will be a QueryableCollection of Tables

// (Currently Tables are not exported... maybe later.)

// Both will be queryable via the Query Service

//

// Other relations will be representable using the Relationship Service

// This includes primary/foreign keys and anything else :)

//

// GRANT/REVOKE can be supplied via the Security Service

//

// See a pattern here? The whole of SQL can be implemented by these services!

// The statements go through a parser. Queries and subqueries are passed to the

// database for processing. Returned items are handled appropriately:

//

// SELECT: return the items to the caller

// UPDATE: modify the items (direct)

// DELETE: call delete() on each Row (direct)

// GRANT/REVOKE: modify ACLs (via Security Service)

// ALTER: modify the items (direct) and/or the relations (via Relationship Service)

// etc.

//

// I'm not sure yet about LOCK and UNLOCK.

// </info>

// Connected database object

interface Database : CosQuery::QueryableCollection {

void disconnect();

};

// Server object (stateless)

interface Server {

Database connect(in string db, in string user, in string password);

};

};

#endif // pgsql_idl