Quelltext der Seite Modul:CargoUtil

local p = {}
local getArgs = require('Module:Arguments').getArgs
local classDebug = require('Module:Debug/class')
local _TT = require('Module:TableTools')
local cargo
if mw.ext and mw.ext.cargo then
	cargo = mw.ext.cargo
else
	cargo = {}
end

function prepareQueryParam(query)
	classDebug:log(21, 'entering CargoUtil.prepareQueryParam', 'CargoUtil')
	if query.tables and #query.tables > 0 and query.fields and #query.fields > 0 then
		if type(query.tables) == 'table' then
			query.tables = table.concat(query.tables, ', ')
		end
		if not query.joins then
			query.joins = query.join
		end
		if query.joins and type(query.joins) == 'table' then
			query.joins = table.concat(query.joins, ', ')
		end
		if type(query.fields) == 'table' then
			query.fields = table.concat(query.fields, ', ')
		end
		if query.where and type(query.where) == 'table' then
			if query.where[1] then	-- sequence assumed
				query.where = table.concat(query.where, ' AND ')
			else
				local where = ''
				for k, v in pairs(query.where) do
					where = where .. k .. '=' .. v .. ' AND '
				end
				query.where = where .. '1 '
			end
		end
		if query.group and type(query.group) == 'table' then
			query.group = table.concat(query.group, ', ')
		end
		if query.having and type(query.having) == 'table' then
			if query.having[1] then	-- sequence assumed
					query.having = table.concat(query.having, ', ')
			else
				local having = ''
				for k, v in pairs(query.having) do
					having = having .. k .. '=' .. v .. ', '
				end
				query.having = mw.ustring.sub(having, 1, -3)
			end
		end
		if query.order and type(query.order) == 'table' then
			query.order = table.concat(query.order, ', ')
		end
		return query
	else
		if tables and #tables > 0 then
			error('Argument query.tables is missing or empty! (calling from ' .. tostring(self) .. ')', 2)
		else
			error('Argument query.fields is missing or empty! (calling from ' .. tostring(self) .. ')', 2)
		end
		return nil
	end	
end

function p.attach(dbtable)
	classDebug:log(21, 'entering CargoUtil.attach', 'CargoUtil.attach')
	classDebug:log(22, ' with table "' .. dbtable .. '"')
	local frame = mw.getCurrentFrame()
	local ret = false
	ret = frame:callParserFunction('#cargo_attach:_table=' .. dbtable)
	return ret
end

function p.declare(dbtable, dbfields)
	classDebug:log(21, 'entering CargoUtil.declare', 'CargoUtil.declare')
	classDebug:log(22, ' with table "' .. dbtable .. '" and fields ' ..
		(type(dbfields) == "string" and '"' .. dbfields .. '"' or 'of type ' .. type(dbfields)), 'CargoUtil.declare')
	if type(dbfields) == "table" then
		classDebug:log(23, ' datatable: ' .. _TT.printTable(dbfields), 'CargoUtil.declare')
	end
	local frame = mw.getCurrentFrame()
	local ret = false
	if type(dbfields) == "string" then
		ret = frame:callParserFunction('#cargo_declare:_table=' .. dbtable, dbfields)
	elseif type(dbfields) == "table" then
		ret = frame:callParserFunction{name = '#cargo_declare:_table=' .. dbtable, args = dbfields}
	end
	return ret
end

function p.query(query, attributes, retainBlanks)
	classDebug:log(21, 'entering CargoUtil.query', 'CargoUtil.query')
	classDebug:log(23, ' with query: ' .. (query and _TT.printTable(query) or 'NONE'), 'CargoUtil.query')
	classDebug:log(23, ' with attributes: ' .. (attributes and _TT.printTable(attributes) or 'NONE'), 'CargoUtil.query')
	local attributes = attributes or {}
	if type(attributes) ~= 'table' then
		attributes = {attributes}
	end
	-- CargoUtil.query() allows for query.paramters (like table, where, etc) to be tables. cargo.query only takes strings. remedy this here
	local query = prepareQueryParam(query)
	local args = {
		where = query.where,
		join = query.joins,
		groupBy = query.group,
		having = query.having,
		orderBy = query.order,
		limit = attributes.limit
	}
	local result = cargo.query(query.tables, query.fields, args)

	local ret = {}
	for num, row in pairs(result) do
		local newRow = {}
		for key, value in pairs(row) do
			if mw.ustring.len(mw.text.trim(value)) > 0 or retainBlanks then
				newRow[key] = value
				-- cargo interprets underscored (_) as spaces in fieldnames (keys). so copy the entry
				if mw.ustring.find(key, ' ') then
					local newKey = mw.ustring.gsub(key, ' ', '_')
					if not newRow[newKey] then
						newRow[newKey] = newRow[key]
					end
				end
			end
		end
		ret[num] = newRow
	end

	return ret
end

function p.rawquery(query, attributes)
	classDebug:log(21, 'entering CargoUtil.rawquery', 'CargoUtil.rawquery')
	classDebug:log(23, ' with query: ' .. (query and _TT.printTable(query) or 'NONE'), 'CargoUtil.rawquery')
	classDebug:log(23, ' with attributes: ' .. (attributes and _TT.printTable(attributes) or 'NONE'), 'CargoUtil.rawquery')
	local query = prepareQueryParam(query)
	local frame = mw.getCurrentFrame()
	local tables = query.tables
	local arguments = attributes or {}
	arguments.fields = query.fields
	arguments['join on'] = query.joins
	arguments.where = query.where
	arguments['group by'] = query.group
	arguments.having = query.having
	arguments['order by'] = query.order
	classDebug:log(24, ' calling parser function with tables: ' .. tables .. ' and arguments: ' .. _TT.printTable(arguments))
	return frame:callParserFunction{ name='#cargo_query:tables=' .. tables, args = arguments }
end

function p.store(dbtable, data)
	classDebug:log(21, 'entering CargoUtil.store')
	classDebug:log(22, ' with table "' .. dbtable .. '" and data ' ..
		(type(data) == "string" and '"' .. data .. '"' or 'of type ' .. type(data)))
	if type(data) == "table" then
		classDebug:log(23, ' datatable: ' .. _TT.printTable(data))
	end
	local ret = false
	if type(data) == "table" then
		for k, v in pairs(data) do
			if type(v) == 'boolean' then
				data[k] = v and 1 or 0
			end
		end
		local frame = mw.getCurrentFrame()
		ret = frame:callParserFunction{name = '#cargo_store:_table=' .. dbtable, args = data}
	end
	return ret
end

return p