/*
* Make encoding (compresstype = none, blocksize=...). We do this for the case
* where the user has not specified an encoding for the column.
*/
List *
default_column_encoding_clause(void)
{
DefElem *e1 = makeDefElem("compresstype", (Node *)makeString("none"));
DefElem *e2 = makeDefElem("blocksize",
(Node *)makeInteger(DEFAULT_APPENDONLY_BLOCK_SIZE));
DefElem *e3 = makeDefElem("compresslevel",
(Node *)makeInteger(0));
return list_make3(e1, e2, e3);
}
/*
* GUC array: all non-PGC_USERSET, return the same array
*/
void
test__GUCArrayReset__all_non_userset_guc(void **state)
{
ArrayType *in;
ArrayType *out;
Datum d;
List *guc_list;
bool isnull;
int i;
int elems;
build_guc_variables();
will_return(superuser, false);
/* construct text array */
elems = 3;
guc_list = list_make3("log_error_verbosity=terse", "gp_log_format=csv", "maintenance_mode=true");
in = create_guc_array(guc_list, elems);
out = GUCArrayReset(in);
assert_not_null(out);
assert_int_equal(ARR_DIMS(out)[0], elems);
/* check element 1 */
i = 1;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("log_error_verbosity=terse"), VARLEN(d));
assert_memory_equal(VARDATA(d), "log_error_verbosity=terse", VARLEN(d));
/* check element 2 */
i = 2;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("gp_log_format=csv"), VARLEN(d));
assert_memory_equal(VARDATA(d), "gp_log_format=csv", VARLEN(d));
/* check element 3 */
i = 3;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("maintenance_mode=true"), VARLEN(d));
assert_memory_equal(VARDATA(d), "maintenance_mode=true", VARLEN(d));
list_free(guc_list);
pfree(in);
pfree(out);
}
/*
* sort_names accepts three strings, places them in a list, then calls SortList
* to test its sort functionality. Returns a string containing sorted lines.
*/
Datum
sort_names(PG_FUNCTION_ARGS)
{
char *first = PG_GETARG_CSTRING(0);
char *second = PG_GETARG_CSTRING(1);
char *third = PG_GETARG_CSTRING(2);
List *nameList = SortList(list_make3(first, second, third),
(int (*)(const void *, const void *))(&CompareStrings));
StringInfo sortedNames = makeStringInfo();
ListCell *nameCell = NULL;
foreach(nameCell, nameList)
{
char *name = lfirst(nameCell);
appendStringInfo(sortedNames, "%s\n", name);
}
/*
* Make encoding (compresstype = none, blocksize=...) based on
* currently configured defaults.
*/
List *
default_column_encoding_clause(void)
{
const StdRdOptions *ao_opts = currentAOStorageOptions();
DefElem *e1, *e2, *e3;
if (ao_opts->compresstype)
{
e1 = makeDefElem("compresstype",
(Node *)makeString(pstrdup(ao_opts->compresstype)));
}
else
{
e1 = makeDefElem("compresstype", (Node *)makeString("none"));
}
e2 = makeDefElem("blocksize",
(Node *)makeInteger(ao_opts->blocksize));
e3 = makeDefElem("compresslevel",
(Node *)makeInteger(ao_opts->compresslevel));
return list_make3(e1, e2, e3);
}
/*
* GUC array: all PGC_USERSET, return NULL
*/
void
test__GUCArrayReset__all_userset_guc(void **state)
{
ArrayType *in;
List *guc_list;
int elems;
build_guc_variables();
will_return(superuser, false);
/* construct text array */
elems = 3;
guc_list = list_make3("application_name=unittest", "password_encryption=off", "backslash_quote=off");
in = create_guc_array(guc_list, elems);
assert_null(GUCArrayReset(in));
list_free(guc_list);
pfree(in);
}
/*
* GetStreamScanPlan
*/
ForeignScan *
GetStreamScanPlan(PlannerInfo *root, RelOptInfo *baserel,
Oid relid, ForeignPath *best_path, List *tlist, List *scan_clauses, Plan *outer_plan)
{
StreamFdwInfo *sinfo = (StreamFdwInfo *) baserel->fdw_private;
List *physical_tlist = build_physical_tlist(root, baserel);
RangeTblEntry *rte = NULL;
int i;
TableSampleClause *sample;
Value *sample_cutoff = NULL;
/* Reduce RestrictInfo list to bare expressions; ignore pseudoconstants */
scan_clauses = extract_actual_clauses(scan_clauses, false);
for (i = 1; i <= root->simple_rel_array_size; i++)
{
rte = root->simple_rte_array[i];
if (rte && rte->relid == relid)
break;
}
if (!rte || rte->relid != relid)
elog(ERROR, "stream RTE missing");
sample = rte->tablesample;
if (sample)
{
double dcutoff;
Datum d;
ExprContext *econtext;
bool isnull;
Node *node;
Expr *expr;
ExprState *estate;
ParseState *ps = make_parsestate(NULL);
float4 percent;
if (sample->tsmhandler != BERNOULLI_OID)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("tablesample method %s is not supported by streams", get_func_name(sample->tsmhandler)),
errhint("Only bernoulli tablesample method can be used with streams.")));
if (sample->repeatable)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("streams don't support the REPEATABLE clause for tablesample")));
econtext = CreateStandaloneExprContext();
ps = make_parsestate(NULL);
node = (Node *) linitial(sample->args);
node = transformExpr(ps, node, EXPR_KIND_OTHER);
expr = expression_planner((Expr *) node);
estate = ExecInitExpr(expr, NULL);
d = ExecEvalExpr(estate, econtext, &isnull, NULL);
free_parsestate(ps);
FreeExprContext(econtext, false);
percent = DatumGetFloat4(d);
if (percent < 0 || percent > 100 || isnan(percent))
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLESAMPLE_ARGUMENT),
errmsg("sample percentage must be between 0 and 100")));
dcutoff = rint(((double) RAND_MAX + 1) * percent / 100);
sample_cutoff = makeInteger((int) dcutoff);
}
return make_foreignscan(tlist, scan_clauses, baserel->relid,
NIL, list_make3(sinfo->colnames, physical_tlist, sample_cutoff), NIL, NIL, outer_plan);
}
