"""
Import data from an XML file into a table in an Oracle database.
"""
import cx_Logging
import cx_LoggingOptions
import cx_OptionParser
import cx_OracleUtils
import sys
import time
import xml.etree.cElementTree
import Options
# parse command line
parser = cx_OptionParser.OptionParser()
parser.AddOption(cx_OracleUtils.SchemaOption())
parser.AddOption(Options.ARRAY_SIZE)
parser.AddOption(Options.COMMIT_POINT)
parser.AddOption(Options.REPORT_POINT)
parser.AddOption(Options.SET_ROLE)
parser.AddOption(Options.DATE_FORMAT)
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument("fileName",
required=True,
help="the name of the file from which to read the data or "
"'-' to read the exported data from stdin")
parser.AddArgument("tableName",
required=True,
help="the name of the table into which to import the data")
options = parser.Parse()
"""
Backs up an Oracle database.
"""
import cx_LoggingOptions
import cx_OptionParser
import os
import sys
import BackupSet
import Exceptions
import Manager
import Options
# parse command line
parser = cx_OptionParser.OptionParser("BackupDB")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption(Options.SYS_PASSWORD)
parser.AddOption(Options.TNSENTRY)
parser.AddOption(Options.NO_START)
parser.AddOption("--offline",
default=False,
action="store_true",
help="perform an offline backup with the database shut down")
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument("sid",
required=True,
help="the SID of the database to backup")
parser.AddArgument(
"backupName",
required=True,
"""Make the frozen base executables."""
import cx_OptionParser
import distutils.sysconfig
import os
import sys
# parse command line
parser = cx_OptionParser.OptionParser("MakeFrozenBases")
options = parser.Parse()
def runcmd(command):
print command
return os.system(command)
# define function for building a base executable
def BuildBase(name, linkerFlags="", sharedLib=False):
vars = distutils.sysconfig.get_config_vars()
sourceName = name + ".c"
objectName = name + ".o"
targetName = name + "Base"
targetName += vars["EXE"]
compilerFlags = "-c -I. -I%s" % distutils.sysconfig.get_python_inc()
linkerFlags += " -s"
linkerFlags += " -L%s" % vars["LIBPL"]
linkerFlags += " -L ../tvision-py/makes"
linkerFlags += " ../all_wrap.o ../inithelper.o"
linkerFlags += " " + objectName
linkerFlags += " -lpython%d.%d" % sys.version_info[:2]
import cx_Logging
import cx_LoggingOptions
import cx_OptionParser
import cx_ShellUtils
import os
import sys
import Database
import Exceptions
import Manager
import Options
import Utils
# parse command line
parser = cx_OptionParser.OptionParser("CloneDB")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption(Options.SYS_PASSWORD)
parser.AddOption(Options.TNSENTRY)
parser.AddOption(Options.NO_PROMPTS)
parser.AddOption(Options.REPLACE_EXISTING)
parser.AddOption(Options.NO_START)
parser.AddOption("--offline",
default=False,
action="store_true",
help="perform an offline copy with the database shut down")
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument("origSid",
required=True,
help="the SID of the database to clone")
parser.AddArgument("newSid",
import cx_OptionParser
import cx_OracleParser
parser = cx_OptionParser.OptionParser("TestParser")
parser.AddOption("--production-name",
default="file",
help="the name of the production to look for")
parser.AddArgument("fileName",
required=True,
help="the name of the file to parse")
options = parser.Parse()
parser = cx_OracleParser.Parser()
try:
for statement in parser.Parse(open(options.fileName).read(),
"dummy",
productionName=options.productionName):
print(statement)
except cx_OracleParser.ParsingFailed as value:
print("Parsing failed at position:", value.arguments["pos"])
print("Remaining string:", value.arguments["remainingString"])
"""
Export the parameter file for the database which will be included in any
backups.
"""
import cx_LoggingOptions
import cx_OptionParser
import sys
import Exceptions
import Manager
import Options
# parse command line
parser = cx_OptionParser.OptionParser("ExportControlFile")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption(Options.SYS_PASSWORD)
parser.AddOption(Options.TNSENTRY)
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument(
"sid",
required=True,
help="the SID of the database to export the control file for")
parser.AddArgument("fileName",
help="the name of the file in which to place the output")
options = parser.Parse()
cx_LoggingOptions.ProcessOptions(options)
# create the manager
manager = Manager.Manager(options.configFileName)
database = manager.DatabaseFromEnvironment(options.sysPassword,
"""
Shows the memory used by the database.
"""
import cx_LoggingOptions
import cx_OptionParser
import os
# parse command line
parser = cx_OptionParser.OptionParser("ShowMemoryDB")
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument(
"sid",
required=True,
help="the SID of the database for which memory usage will be shown")
options = parser.Parse()
cx_LoggingOptions.ProcessOptions(options)
# define method that returns a list of pids
def GetPids(mask):
pids = []
for line in os.popen("ps -ef | grep %s | grep -v grep" % mask):
parts = line.strip().split()
pids.append(int(parts[1]))
return pids
# define method that returns the formatted size in KB or MB
def FormattedSize(size):
size = size / 1024
"""Freeze a Python script and all of its referenced modules to a base
executable which can then be distributed without requiring a Python
installation."""
import cx_Freezer
import cx_OptionParser
import cx_ShellUtils
import os
import sys
# parse command line
parser = cx_OptionParser.OptionParser("FreezePython")
parser.AddOption("--base-binary", required = True, metavar = "NAME",
default = os.environ.get("FREEZE_PYTHON_BASE"),
help = "Base binary instead of $FREEZE_PYTHON_BASE")
parser.AddOption("--install-dir", required = True, metavar = "DIR",
default = os.environ.get("FREEZE_PYTHON_INSTALL_DIR"),
help = "Location to install binary instead of "
"$FREEZE_PYTHON_INSTALL_DIR.")
parser.AddOption("--target-name", metavar = "NAME",
help = "Name of binary to create instead of script.extension")
parser.AddOption("--shared-library", action = "store_true",
help = "do not generate __main__ for the name of the module")
parser.AddOption("--keep-path", action = "store_false",
dest = "overridePath", default = True,
help = "do not override the path in the frozen executable")
parser.AddOption("--include-modules", action = "append", metavar = "LIST",
help = "name(s) of module(s) to include in the frozen binary")
parser.AddOption("--exclude-modules", action = "append", metavar = "LIST",
help = "name(s) of module(s) to exclude from the frozen binary")
parser.AddOption("--ext-list-file", metavar = "FILE",
"""
Stop an Oracle database.
"""
import cx_Logging
import cx_LoggingOptions
import cx_OptionParser
import Manager
import Options
# parse command line
parser = cx_OptionParser.OptionParser("StopDB")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption(Options.SYS_PASSWORD)
parser.AddOption(Options.TNSENTRY)
parser.AddOption(Options.SHUTDOWN_MODE)
parser.AddOption("--all",
action="store_true",
help="stop all configured databases")
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument(
"sids", help="the SID(s) of the database(s) to stop, separated by commas")
options = parser.Parse()
cx_LoggingOptions.ProcessOptions(options)
# perform the work
manager = Manager.Manager(options.configFileName)
database = manager.DatabaseFromEnvironment(options.sysPassword,
options.tnsentry)
if database is not None:
"""
Creates an Oracle database.
"""
import cx_ClassLibrary
import cx_LoggingOptions
import cx_OptionParser
import socket
import Database
import Exceptions
import Options
import Manager
# parse command line
parser = cx_OptionParser.OptionParser("CreateDB")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption("--type",
dest="databaseType",
metavar="STR",
help="the type of database to create; if omitted the default "
"type is used")
parser.AddOption("--start-mode",
default="Manual",
metavar="MODE",
help="the start mode for the database (Manual or Auto)")
parser.AddOption("--sys-password",
metavar="STR",
default=socket.gethostname().split(".")[0],
help="the sys password for the new database; if omitted the "
"name of the machine is used")
"""
Starts up an Oracle database.
"""
import cx_Logging
import cx_LoggingOptions
import cx_OptionParser
import Manager
import Options
# parse command line
parser = cx_OptionParser.OptionParser("StartDB")
parser.AddOption(Options.CONFIG_FILE_NAME)
parser.AddOption(Options.SYS_PASSWORD)
parser.AddOption(Options.TNSENTRY)
parser.AddOption("-r", "--restart", action = "store_true",
help = "shut down the database first if already started")
parser.AddOption(Options.SHUTDOWN_MODE)
parser.AddOption("--all", action = "store_true",
help = "start all configured databases")
parser.AddOption("--all-auto", action = "store_true",
help = "start all configured databases set to automatic start")
cx_LoggingOptions.AddOptions(parser)
parser.AddArgument("sids",
help = "the SID(s) of the database(s) to start, separated by commas")
options = parser.Parse()
cx_LoggingOptions.ProcessOptions(options)
# perform the work
manager = Manager.Manager(options.configFileName)
"""
Dump the results of a SQL select statement to a file in CSV format.
"""
import csv
import cx_Logging
import cx_LoggingOptions
import cx_OptionParser
import cx_OracleUtils
import sys
import Options
# parse command line
parser = cx_OptionParser.OptionParser("DumpCSV")
parser.AddOption(cx_OracleUtils.SchemaOption())
parser.AddOption("--record-sep",
default="\n",
metavar="CHAR",
help="record separator to use")
parser.AddOption("--field-sep",
default=",",
metavar="CHAR",
help="field separator to use")
parser.AddOption("--string-encloser",
default='"',
metavar="CHAR",
help="character to use for enclosing strings")
parser.AddOption("--escape-char",
default="\\",
metavar="CHAR",
