duckdb::CatalogSearchEntry Struct Reference

Collaboration diagram for duckdb::CatalogSearchEntry:

Public Member Functions
	CatalogSearchEntry (string catalog, string schema)
string	ToString () const

Static Public Member Functions
static string	ListToString (const vector< CatalogSearchEntry > &input)
static CatalogSearchEntry	Parse (const string &input)
static vector< CatalogSearchEntry >	ParseList (const string &input)

Public Attributes
string	catalog
string	schema

Static Private Member Functions
static CatalogSearchEntry	ParseInternal (const string &input, idx_t &pos)
static string	WriteOptionallyQuoted (const string &input)

Constructor & Destructor Documentation

CatalogSearchEntry()

duckdb::CatalogSearchEntry::CatalogSearchEntry	(	string	catalog,
		string	schema
	)

    : catalog(std::move(catalog_p)), schema(std::move(schema_p)) {
}

Member Function Documentation

ToString()

string duckdb::CatalogSearchEntry::ToString

(

)

const

                                          {
    if (catalog.empty()) {
        return WriteOptionallyQuoted(schema);
    } else {
        return WriteOptionallyQuoted(catalog) + "." + WriteOptionallyQuoted(schema);
    }
}

ListToString()

string duckdb::CatalogSearchEntry::ListToString ( const vector< CatalogSearchEntry > &  input )

static

                                                                               {
    string result;
    for (auto &entry : input) {
        if (!result.empty()) {
            result += ",";
        }
        result += entry.ToString();
    }
    return result;
}

Parse()

CatalogSearchEntry duckdb::CatalogSearchEntry::Parse ( const string &  input )

static

                                                                {
    idx_t pos = 0;
    auto result = ParseInternal(input, pos);
    if (pos < input.size()) {
        throw ParserException("Failed to convert entry \"%s\" to CatalogSearchEntry - expected a single entry", input);
    }
    return result;
}

ParseList()

vector< CatalogSearchEntry > duckdb::CatalogSearchEntry::ParseList ( const string &  input )

static

                                                                            {
    idx_t pos = 0;
    vector<CatalogSearchEntry> result;
    while (pos < input.size()) {
        auto entry = ParseInternal(input, pos);
        result.push_back(entry);
    }
    return result;
}

ParseInternal()

CatalogSearchEntry duckdb::CatalogSearchEntry::ParseInternal ( const string &  input, idx_t &  pos  )

staticprivate

look for another quote

unquote

                                                                                    {
    string catalog;
    string schema;
    string entry;
    bool finished = false;
normal:
    for (; idx < input.size(); idx++) {
        if (input[idx] == '"') {
            idx++;
            goto quoted;
        } else if (input[idx] == '.') {
            goto separator;
        } else if (input[idx] == ',') {
            finished = true;
            goto separator;
        }
        entry += input[idx];
    }
    finished = true;
    goto separator;
quoted:
    for (; idx < input.size(); idx++) {
        if (input[idx] == '"') {
            idx++;
            if (idx < input.size() && input[idx] == '"') {
                // escaped quote
                entry += input[idx];
                continue;
            }
            goto normal;
        }
        entry += input[idx];
    }
    throw ParserException("Unterminated quote in qualified name!");
separator:
    if (entry.empty()) {
        throw ParserException("Unexpected dot - empty CatalogSearchEntry");
    }
    if (schema.empty()) {
        // if we parse one entry it is the schema
        schema = std::move(entry);
    } else if (catalog.empty()) {
        // if we parse two entries it is [catalog.schema]
        catalog = std::move(schema);
        schema = std::move(entry);
    } else {
        throw ParserException("Too many dots - expected [schema] or [catalog.schema] for CatalogSearchEntry");
    }
    entry = "";
    idx++;
    if (finished) {
        goto final;
    }
    goto normal;
final:
    if (schema.empty()) {
        throw ParserException("Unexpected end of entry - empty CatalogSearchEntry");
    }
    return CatalogSearchEntry(std::move(catalog), std::move(schema));
}

WriteOptionallyQuoted()

string duckdb::CatalogSearchEntry::WriteOptionallyQuoted ( const string &  input )

staticprivate

                                                                    {
    for (idx_t i = 0; i < input.size(); i++) {
        if (input[i] == '.' || input[i] == ',' || input[i] == '"') {
            return "\"" + StringUtil::Replace(input, "\"", "\"\"") + "\"";
        }
    }
    return input;
}

---

The documentation for this struct was generated from the following file:

• external/duckdb/duckdb.cpp