/*
* CStoreTable checks if the given table name belongs to a foreign columnar store
* table. If it does, the function returns true. Otherwise, it returns false.
*/
static bool
CStoreTable(RangeVar *rangeVar)
{
bool cstoreTable = false;
Relation relation = heap_openrv(rangeVar, AccessShareLock);
Oid relationId = RelationGetRelid(relation);
char relationKind = get_rel_relkind(relationId);
if (relationKind == RELKIND_FOREIGN_TABLE)
{
ForeignTable *foreignTable = GetForeignTable(relationId);
ForeignServer *server = GetForeignServer(foreignTable->serverid);
ForeignDataWrapper *foreignDataWrapper = GetForeignDataWrapper(server->fdwid);
char *foreignWrapperName = foreignDataWrapper->fdwname;
if (strncmp(foreignWrapperName, CSTORE_FDW_NAME, NAMEDATALEN) == 0)
{
cstoreTable = true;
}
}
heap_close(relation, AccessShareLock);
return cstoreTable;
}
void tdsGetForeignTableOptionsFromCatalog(Oid foreigntableid, TdsFdwOptionSet* option_set)
{
ForeignTable *f_table;
ForeignServer *f_server;
UserMapping *f_mapping;
#ifdef DEBUG
ereport(NOTICE,
(errmsg("----> starting tdsGetForeignTableOptionsFromCatalog")
));
#endif
tdsOptionSetInit(option_set);
f_table = GetForeignTable(foreigntableid);
f_server = GetForeignServer(f_table->serverid);
f_mapping = GetUserMapping(GetUserId(), f_table->serverid);
tdsGetForeignServerOptions(f_server->options, option_set);
tdsGetForeignServerTableOptions(f_server->options, option_set);
tdsGetForeignTableOptions(f_table->options, option_set);
tdsGetUserMappingOptions(f_mapping->options, option_set);
tdsSetDefaultOptions(option_set);
tdsValidateOptionSet(option_set);
#ifdef DEBUG
ereport(NOTICE,
(errmsg("----> finishing tdsGetForeignTableOptionsFromCatalog")
));
#endif
}
/*
* pg_get_extensiondef_string finds the foreign data wrapper that corresponds to
* the given foreign tableId, and checks if an extension owns this foreign data
* wrapper. If it does, the function returns the extension's definition. If not,
* the function returns null.
*/
char *
pg_get_extensiondef_string(Oid tableRelationId)
{
ForeignTable *foreignTable = GetForeignTable(tableRelationId);
ForeignServer *server = GetForeignServer(foreignTable->serverid);
ForeignDataWrapper *foreignDataWrapper = GetForeignDataWrapper(server->fdwid);
StringInfoData buffer = { NULL, 0, 0, 0 };
Oid classId = ForeignDataWrapperRelationId;
Oid objectId = server->fdwid;
Oid extensionId = getExtensionOfObject(classId, objectId);
if (OidIsValid(extensionId))
{
char *extensionName = get_extension_name(extensionId);
Oid extensionSchemaId = get_extension_schema(extensionId);
char *extensionSchema = get_namespace_name(extensionSchemaId);
initStringInfo(&buffer);
appendStringInfo(&buffer, "CREATE EXTENSION IF NOT EXISTS %s WITH SCHEMA %s",
quote_identifier(extensionName),
quote_identifier(extensionSchema));
}
else
{
ereport(NOTICE, (errmsg("foreign-data wrapper \"%s\" does not have an "
"extension defined", foreignDataWrapper->fdwname)));
}
return (buffer.data);
}
/*
* pg_get_serverdef_string finds the foreign server that corresponds to the
* given foreign tableId, and returns this server's definition.
*/
char *
pg_get_serverdef_string(Oid tableRelationId)
{
ForeignTable *foreignTable = GetForeignTable(tableRelationId);
ForeignServer *server = GetForeignServer(foreignTable->serverid);
ForeignDataWrapper *foreignDataWrapper = GetForeignDataWrapper(server->fdwid);
StringInfoData buffer = { NULL, 0, 0, 0 };
initStringInfo(&buffer);
appendStringInfo(&buffer, "CREATE SERVER %s", quote_identifier(server->servername));
if (server->servertype != NULL)
{
appendStringInfo(&buffer, " TYPE %s",
quote_literal_cstr(server->servertype));
}
if (server->serverversion != NULL)
{
appendStringInfo(&buffer, " VERSION %s",
quote_literal_cstr(server->serverversion));
}
appendStringInfo(&buffer, " FOREIGN DATA WRAPPER %s",
quote_identifier(foreignDataWrapper->fdwname));
/* append server options, if any */
AppendOptionListToString(&buffer, server->options);
return (buffer.data);
}
static void
getTableOptions(Oid foreigntableid,struct ktTableOptions *table_options)
{
ForeignTable *table;
ForeignServer *server;
UserMapping *mapping;
List *options;
ListCell *lc;
#ifdef DEBUG
elog(NOTICE, "getTableOptions");
#endif
/*
* Extract options from FDW objects. We only need to worry about server
* options for Redis
*
*/
table = GetForeignTable(foreigntableid);
server = GetForeignServer(table->serverid);
mapping = GetUserMapping(GetUserId(), table->serverid);
table_options->userId = mapping->userid;
table_options->serverId = server->serverid;
options = NIL;
options = list_concat(options, table->options);
options = list_concat(options, server->options);
options = list_concat(options, mapping->options);
// table_options->table_type = PG_REDIS_SCALAR_TABLE;
/* Loop through the options, and get the server/port */
foreach(lc, options)
{
DefElem *def = (DefElem *) lfirst(lc);
if (strcmp(def->defname, "host") == 0)
table_options->host = defGetString(def);
if (strcmp(def->defname, "port") == 0)
table_options->port = atoi(defGetString(def));
if (strcmp(def->defname, "timeout") == 0)
table_options->timeout = atoi(defGetString(def));
}
/*
* CStoreTable returns true if the given relationId belongs to a foreign cstore
* table, otherwise it returns false.
*/
bool
CStoreTable(Oid relationId)
{
bool cstoreTable = false;
char relationKind = get_rel_relkind(relationId);
if (relationKind == RELKIND_FOREIGN_TABLE)
{
ForeignTable *foreignTable = GetForeignTable(relationId);
ForeignServer *server = GetForeignServer(foreignTable->serverid);
ForeignDataWrapper *foreignDataWrapper = GetForeignDataWrapper(server->fdwid);
if (strncmp(foreignDataWrapper->fdwname, CSTORE_FDW_NAME, NAMEDATALEN) == 0)
{
cstoreTable = true;
}
}
return cstoreTable;
}
static void
getTableOptions(Oid foreigntableid, struct wdbTableOptions *table_options) {
ForeignTable* table;
ForeignServer* server;
UserMapping* mapping;
List* options = NIL;
ListCell* lc = NULL;
#ifdef DEBUG
elog(NOTICE, "getTableOptions");
#endif
/*
* Extract options from FDW objects.
*
*/
table = GetForeignTable(foreigntableid);
server = GetForeignServer(table->serverid);
mapping = GetUserMapping(GetUserId(), table->serverid);
table_options->userId = mapping->userid;
table_options->serverId = server->serverid;
options = NIL;
options = list_concat(options, table->options);
options = list_concat(options, server->options);
options = list_concat(options, mapping->options);
/* Loop through the options, and get the server/port */
foreach(lc, options)
{
DefElem *def = (DefElem *) lfirst(lc);
if (strcmp(def->defname, "address") == 0)
table_options->address = defGetString(def);
if (strcmp(def->defname, "size") == 0)
table_options->size = atoi(defGetString(def));
}
static javaFdwExecutionState* javaGetOptions(Oid foreigntableid) {
ForeignTable *f_table;
ForeignServer *f_server;
UserMapping *f_mapping;
List *options;
ListCell *cell;
jobject obj, res, serverClass;
jmethodID serverConstructor;
jclass cl;
javaFdwExecutionState *state;
char *classname = NULL;
options = NIL;
f_table = GetForeignTable(foreigntableid);
options = list_concat(options, f_table->options);
f_server = GetForeignServer(f_table->serverid);
options = list_concat(options, f_server->options);
PG_TRY();
{
f_mapping = GetUserMapping(GetUserId(), f_table->serverid);
options = list_concat(options, f_mapping->options);
}
PG_CATCH();
{
FlushErrorState();
/* DO NOTHING HERE */
}
PG_END_TRY();
foreach(cell, options) {
DefElem *def = (DefElem *) lfirst(cell);
if (strcmp(def->defname, "class") == 0) {
classname = (char *) defGetString(def);
}
}
static const char *
sonar_get_option(const char *optname, Oid tbl)
{
ForeignTable *foreignTable = NULL;
List *optionList = NIL;
ListCell *optionCell = NULL;
const char *val = NULL;
foreignTable = GetForeignTable(tbl);
optionList = list_concat(optionList, foreignTable->options);
foreach(optionCell, optionList)
{
DefElem *optionDef = (DefElem *) lfirst(optionCell);
char *optionDefName = optionDef->defname;
if (strncmp(optionDefName, optname, NAMEDATALEN) == 0)
{
val = defGetString(optionDef);
break;
}
}
/*
* pg_get_tableschemadef_string returns the definition of a given table. This
* definition includes table's schema, default column values, not null and check
* constraints. The definition does not include constraints that trigger index
* creations; specifically, unique and primary key constraints are excluded.
*/
static char *
pg_shard_get_tableschemadef_string(Oid tableRelationId)
{
Relation relation = NULL;
char *relationName = NULL;
char relationKind = 0;
TupleDesc tupleDescriptor = NULL;
TupleConstr *tupleConstraints = NULL;
int attributeIndex = 0;
bool firstAttributePrinted = false;
AttrNumber defaultValueIndex = 0;
AttrNumber constraintIndex = 0;
AttrNumber constraintCount = 0;
StringInfoData buffer = { NULL, 0, 0, 0 };
/*
* Instead of retrieving values from system catalogs as other functions in
* ruleutils.c do, we follow an unusual approach here: we open the relation,
* and fetch the relation's tuple descriptor. We do this because the tuple
* descriptor already contains information harnessed from pg_attrdef,
* pg_attribute, pg_constraint, and pg_class; and therefore using the
* descriptor saves us from a lot of additional work.
*/
relation = relation_open(tableRelationId, AccessShareLock);
relationName = generate_relation_name(tableRelationId);
relationKind = relation->rd_rel->relkind;
if (relationKind != RELKIND_RELATION && relationKind != RELKIND_FOREIGN_TABLE)
{
ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("%s is not a regular or foreign table", relationName)));
}
initStringInfo(&buffer);
if (relationKind == RELKIND_RELATION)
{
appendStringInfo(&buffer, "CREATE TABLE %s (", relationName);
}
else
{
appendStringInfo(&buffer, "CREATE FOREIGN TABLE %s (", relationName);
}
/*
* Iterate over the table's columns. If a particular column is not dropped
* and is not inherited from another table, print the column's name and its
* formatted type.
*/
tupleDescriptor = RelationGetDescr(relation);
tupleConstraints = tupleDescriptor->constr;
for (attributeIndex = 0; attributeIndex < tupleDescriptor->natts; attributeIndex++)
{
Form_pg_attribute attributeForm = tupleDescriptor->attrs[attributeIndex];
if (!attributeForm->attisdropped && attributeForm->attinhcount == 0)
{
const char *attributeName = NULL;
const char *attributeTypeName = NULL;
if (firstAttributePrinted)
{
appendStringInfoString(&buffer, ", ");
}
firstAttributePrinted = true;
attributeName = NameStr(attributeForm->attname);
appendStringInfo(&buffer, "%s ", quote_identifier(attributeName));
attributeTypeName = format_type_with_typemod(attributeForm->atttypid,
attributeForm->atttypmod);
appendStringInfoString(&buffer, attributeTypeName);
/* if this column has a default value, append the default value */
if (attributeForm->atthasdef)
{
AttrDefault *defaultValueList = NULL;
AttrDefault *defaultValue = NULL;
Node *defaultNode = NULL;
List *defaultContext = NULL;
char *defaultString = NULL;
Assert(tupleConstraints != NULL);
defaultValueList = tupleConstraints->defval;
Assert(defaultValueList != NULL);
defaultValue = &(defaultValueList[defaultValueIndex]);
defaultValueIndex++;
Assert(defaultValue->adnum == (attributeIndex + 1));
Assert(defaultValueIndex <= tupleConstraints->num_defval);
/* convert expression to node tree, and prepare deparse context */
defaultNode = (Node *) stringToNode(defaultValue->adbin);
defaultContext = deparse_context_for(relationName, tableRelationId);
/* deparse default value string */
defaultString = deparse_expression(defaultNode, defaultContext,
false, false);
appendStringInfo(&buffer, " DEFAULT %s", defaultString);
}
/* if this column has a not null constraint, append the constraint */
if (attributeForm->attnotnull)
{
appendStringInfoString(&buffer, " NOT NULL");
}
}
}
/*
* Now check if the table has any constraints. If it does, set the number of
* check constraints here. Then iterate over all check constraints and print
* them.
*/
if (tupleConstraints != NULL)
{
constraintCount = tupleConstraints->num_check;
}
for (constraintIndex = 0; constraintIndex < constraintCount; constraintIndex++)
{
ConstrCheck *checkConstraintList = tupleConstraints->check;
ConstrCheck *checkConstraint = &(checkConstraintList[constraintIndex]);
Node *checkNode = NULL;
List *checkContext = NULL;
char *checkString = NULL;
/* if an attribute or constraint has been printed, format properly */
if (firstAttributePrinted || constraintIndex > 0)
{
appendStringInfoString(&buffer, ", ");
}
appendStringInfo(&buffer, "CONSTRAINT %s CHECK ",
quote_identifier(checkConstraint->ccname));
/* convert expression to node tree, and prepare deparse context */
checkNode = (Node *) stringToNode(checkConstraint->ccbin);
checkContext = deparse_context_for(relationName, tableRelationId);
/* deparse check constraint string */
checkString = deparse_expression(checkNode, checkContext, false, false);
appendStringInfoString(&buffer, checkString);
}
/* close create table's outer parentheses */
appendStringInfoString(&buffer, ")");
/*
* If the relation is a foreign table, append the server name and options to
* the create table statement.
*/
if (relationKind == RELKIND_FOREIGN_TABLE)
{
ForeignTable *foreignTable = GetForeignTable(tableRelationId);
ForeignServer *foreignServer = GetForeignServer(foreignTable->serverid);
char *serverName = foreignServer->servername;
appendStringInfo(&buffer, " SERVER %s", quote_identifier(serverName));
AppendOptionListToString(&buffer, foreignTable->options);
}
relation_close(relation, AccessShareLock);
return (buffer.data);
}